精华内容
下载资源
问答
  • 要求:代码生成jar包,浏览器登陆后,运行jar包时,将获取浏览器SESSIONID值,并发数,测试接口地址作为参数传进去。注意:获取sessionID时,需要在开头拼接上"SESSION="字符串,若有就不需要拼接了; ...

    要求:代码生成jar包,浏览器登陆后,运行jar包时,将获取浏览器SESSIONID值,并发数,测试接口地址作为参数传进去。注意:获取sessionID时,需要在开头拼接上"SESSION="字符串,若有就不需要拼接了;

    package com.dhc.runmain;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.URL;
    import java.net.URLConnection;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class InitMainEnt {
    
    	public static void main(String[] argsq) {
    		
    		String[] args={"1",
    				"http://localhost:8083/ccb-webfront/login/login1.do", 
    				"SESSION=MDUwYTEyYTktMzM5NS00YzM0LWIzNWItOWI2MjUyYWVhYzU3", 
    				"40"};
    		if("1".equals(args[0])){
    			System.out.println("----------------并发测试开始");
    			multiRuntime(args[1],args[2],Integer.valueOf(args[3]));
    		}else{
    			System.out.println("----------------疲劳测试开始");
    			strain(args[1],args[2]);
    		}
    		
    	}
    	
    	/**
    	 * 压力测试
    	 * 
    	 */
    	
    	public static void multiRuntime(String url,String sessionId,int count){
    //		int count = 10;//设置并发数量
    		int z =0;
    		while(true){
    			z++;
    			//线程池准备
    			CyclicBarrier cyclicBarrier = new CyclicBarrier(count);
    			ExecutorService executorService = Executors.newFixedThreadPool(count);
    			long now = System.currentTimeMillis();//开始时间
    			for (int i = 0; i < count; i++){
    				
    				executorService.execute(new InitMainEnt().new Task(cyclicBarrier,i,url,sessionId));
    			}
    			
    			executorService.shutdown();
    			while (!executorService.isTerminated()) {
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    			long end = System.currentTimeMillis();//结束时间
    			System.out.println("第"+z+"批总共耗时!---------"+(end-now));//总共耗时
    		}
    	}
    
    
    	public class Task implements Runnable {
    		private CyclicBarrier cyclicBarrier;
    		private int count;
    		private String url;
    		private String sessionId;
    		public Task(CyclicBarrier cyclicBarrier,int count,String url,String sessionId) {
    			this.cyclicBarrier = cyclicBarrier;
    			this.count = count;
    			this.url=url;
    			this.sessionId=sessionId;
    		}
    
    
    		@Override
    		public void run() {
    			try {
    				// 等待所有任务准备就绪
    				cyclicBarrier.await();
    				System.out.println("线程"+Thread.currentThread().getName()+"开始----------");
    				//测试路径
    				String url_ =url;
    				boolean result = HttpClientUtil.sendPost(url_,sessionId);
    				if(result){
    					System.out.println(result);
    					System.out.println("线程"+Thread.currentThread().getName()+"----------成功");
    				}else{
    					System.out.println(result);
    					System.out.println("线程"+Thread.currentThread().getName()+"----------失败");
    				}
    				cyclicBarrier.await();
    			} catch (Exception e) {
    				System.out.println("出现超时的线程"+count);
    				e.printStackTrace();
    			}
    		}
    	}
    	/**
    	 * 疲劳测试
    	 * 
    	 */
    	
    	public static void strain(String url,String sessionId){
    		long start = System.currentTimeMillis();
    		while(true){
    			boolean result = HttpClientUtil.sendPost(url,sessionId);
    			if(!result){
    				long end = System.currentTimeMillis();//结束时间
    				System.out.println("距离开始时间"+(end-start)/1000 +"秒后,疲劳测试出错");
    			}
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	
    }
    
    package com.dhc.runmain;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.URL;
    import java.net.URLConnection;
    import java.util.List;
    import java.util.Map;
    
    public class HttpClientUtil {
    
    	  public static boolean sendPost(String url,String sessionId) {
    	        PrintWriter out = null;
    	        BufferedReader in = null;
    	        String result = "";
    	        try {
    	        	if(url==null||url.isEmpty()){
    	        		System.out.println("URL为空!");
    	        		return false;
    	        	}
    	            URL realUrl = new URL(url);
    	            // 打开和URL之间的连接
    	            URLConnection conn = realUrl.openConnection();
    	            // 设置通用的请求属性
    //	            conn.setRequestProperty("accept", "*/*");
    //	            conn.setRequestProperty("Cookie", cookie);
    //	            conn.setRequestProperty("connection", "Keep-Alive");
    //	            conn.setRequestProperty("user-agent",
    //	                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
    //	            
    //	            conn.setRequestProperty("Content-Type", "application/json; charset=utf8");
    	            conn.setDoOutput(true);  
    //	            conn.setRequestMethod("GET");  
    	            conn.setRequestProperty("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8");  
    //	            conn.setRequestProperty("Accept-Charset", "GBK,utf-8;q=0.7,*;q=0.3");  
    	            conn.setRequestProperty("Accept-Encoding", "gzip, deflate, br");  
    	            conn.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.9");  
    	            conn.setRequestProperty("Connection", "keep-alive");  
    	            conn.setRequestProperty("Cookie", sessionId);  
    	            conn.setRequestProperty("Host", "localhost:8083");  
    //	            conn.setRequestProperty("Referer", referer);  
    	            conn.setRequestProperty("User-Agent",   
    	                    "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36");  
    	            conn.setRequestProperty("X-Requested-With", "XMLHttpRequest");
    	            // 建立实际的连接  
    	            conn.connect();  
    	            // 获取所有响应头字段  
    	            Map<String, List<String>> map = conn.getHeaderFields();
    	            boolean flag = false;
    	            String content = "";
    	            for (String key : map.keySet()) {
    //	                System.out.println(key + "--->" + map.get(key));
    	            	 content += map.get(key) == null?"":map.get(key).toString().trim();
    	                if(content.indexOf("200")>0){
    	                	flag = true;
    	                	break;
    	                }
    	            }  
    	            in = new BufferedReader(  
    	                    new InputStreamReader(conn.getInputStream(),"utf8"));  
    	            String line;  
    	            while ((line = in.readLine()) != null) {  
    	                result += line;  
    	            }  
    	            if(result!=null&&result.indexOf("errcode\":\"0000")>0){return true;}
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	        }
    	        finally{
    	            try{
    	                if(out!=null){
    	                    out.close();
    	                }
    	                if(in!=null){
    	                    in.close();
    	                }
    	            }
    	            catch(IOException ex){
    	            }
    	        }
    	        return false;
    	    } 
    }
    

     

    展开全文
  • 分享java压力测试模版类

    千次阅读 2014-10-22 17:32:50
    压力测试是对系统不断施加压力的测试,是通过确定一个系统的瓶颈或者不能接收的性能点,来获得系统能提供的最大服务级别的测试。例如测试一个 Web 站点在大量的负荷下,何时系统的响应会退化或失败。网络游戏中也常...

         压力测试是对系统不断施加压力的测试,是通过确定一个系统的瓶颈或者不能接收的性能点,来获得系统能提供的最大服务级别的测试。例如测试一个 Web 站点在大量的负荷下,何时系统的响应会退化或失败。网络游戏中也常用到这个词汇。

         我们在日常一个系统的交付过程中,需要对系统进行压力测试,即单位时间内相应数的测试,常用在web以及数据库和其他网络服务器的开发交付中,对于web的压力测试我们可以选择ab之类的,而jmeter原先是为了web压力测试产生的,目前更是通过插件扩充到了可以进行包括数据库在内的各种压力测试。

         作为一名开发人员,有时候一些简单的测试就不必要动用到那些工具了,就自己写一些代码去搞定了。在写代码的过程中,发觉大部分的压力测试都是统一的模式去做,需要改变的只是不同业务代码。所以我将其抽离成为一个模版类。

    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.atomic.AtomicLong;
    
    /**
     * Commons Test
     *	lsz
     */
    public abstract class AbstractTest 
    {
        int threadNum = 1;
        int sleepTime = 1000;
        long lastTimes = 0;
        int x = 0;
        private AtomicLong now = new AtomicLong();
        private AtomicLong maxTime = new AtomicLong(0l);
        ExecutorService pool = null;
    
        AbstractTest(){
        	this(5);
        }
        public AbstractTest(int threadNum) {
        	this.threadNum = threadNum;
        	pool = Executors.newScheduledThreadPool(this.threadNum);
        	
    	}
        
        
        public abstract void testThreadMethod() throws InterruptedException;
        
        public void start(){
        	for(int i = 0 ; i<threadNum;i ++ ){
        		pool.execute(new TestThread());
        	}
        	String format = "---------------------"+"当前1s内的执行数"+"/"+"总的执行数"+"/"+"平均的执行数"+"/"+"执行的时间"+"/"+"最长执行时间";
        	while(true){
        		try {
        			x++;
    				Thread.sleep(sleepTime);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
        		long nowtmp = now.get();
                System.out.println(format);
        		System.out.println("---------------------"+(nowtmp - lastTimes)+"/"+now.intValue()+"/"+(now.intValue()/x)+"/"+x+"/"+maxTime.get()+"ms");
        		lastTimes = nowtmp;
        	}
        }
        
        class TestThread extends Thread{
        	public TestThread() {
    			
    		}
        	@Override
        	public void run() {
        		System.out.println("start------------------"+Thread.currentThread().getName());
                while (true){
                    try {
                        long start = System.currentTimeMillis();
                        testThreadMethod();
                        long end = System.currentTimeMillis() - start;
                        if(end>maxTime.get()){
                            maxTime.set(end);
                        }
                        now.incrementAndGet();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
    
                }
        	}
        }
    }
    

    "---------------------"+"当前1s内的执行数"+"/"+"总的执行数"+"/"+"平均的执行数"+"/"+"执行的时间"+"/"+"最长执行时间"
     这句话是我输出的内容,这几个结果刚好能够简单的衡量一个系统的性能了。接下来可以看到如何使用这个模版类,也是很简单。只需要实现一个模版方法和指定线程数的重载构造方法即可。

    /**
     * Created by lsz on 14-10-22.
     */
    public class SimpleTest extends AbstractTest {
        public SimpleTest(int threadNum) {
            super(threadNum);
        }
        @Override
        public void testThreadMethod() throws InterruptedException {
            //具体要测试的逻辑或者是请求   
            Thread.sleep(100);
        }
    
        public static void main(String[] args) {
            new SimpleTest(5).start();
        }

    具体的使用也是这么简单。大家可以在实现testThreadMethod来实现自己的压力测试逻辑,比如用httpclient方法一个页面。在代码里面之所以sleep只是防止自旋消耗CPU。可以去掉。有什么可以补充的欢迎讨论!!!

    
    

    展开全文
  • 分享java压力测试模版类 版本2

    千次阅读 2014-10-24 10:55:47
    在上一次,我们分享了一个压力测试的模板类,在模板类里面通过继承然后实现重写几个方法即可以实现压力测试,其本质就是由实现者去实现具体的测试逻辑,将功能代码独立抽离出来实现复用。然而,继承存在着一些缺点是...

            在上一次,我们分享了一个压力测试的模板类,在模板类里面通过继承然后实现重写几个方法即可以实现压力测试,其本质就是由实现者去实现具体的测试逻辑,将功能代码独立抽离出来实现复用。然而,继承存在着一些缺点是无法避免的。比如具体的失去了灵活性,而且如果java不支持多继承,意味着测试类会被限制少了继承其他类的能力,再者之前的代码对外部暴露的接口过多,无法对用户实现彻底的透明。因此对原先的代码采用了Function方式进行重构。

            Function的方式即将函数作为参数传入方法中,由具体的调用者去决定函数的内容,这个刚好是我们需要的,由具体的测试者去实现需要测试的逻辑。可惜在java中并不支持将函数作为参数传入方法中,不能像js那样  function xxx(functionx)去声明调用。不过,在设计模式中有一种叫做命令模式的,我们简单的借用下。

           

    public interface Runnable {
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }

            在java的java.util下有这个Runable的接口,只需要实现run方法即可。

    public void xxx(Runable r){
            r.run();
    }
    
            如果有疑问function不是一个接口吗,那apply方法哪里实现的,这样想就对了。如果要体会这种写法怎么做,可以直接new Function()xxxx看看IDE会怎么帮你自动生成一些代码。这个就是由调用xxx的用户去实现function的内容,在运行该方法的处决定function接口的内容,将实现者和调用者解耦。
           接下来是重构过的测试模板类。正确的说不是模板类了,是直接可以运行的功能类了。

           

    
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;  
    import java.util.concurrent.atomic.AtomicLong;  
      
      
    /** 
     * 通用压力测试类 
     * Created by lsz on 14-10-24. 
     */  
    public class CommonsTest {  
        int threadNum = 1;  
        int sleepTime = 1000;  
        long lastTimes = 0;  
        int x = 0;  
        private AtomicLong now = new AtomicLong();  
        private AtomicLong maxTime = new AtomicLong(0l);  
        ExecutorService pool = null;  
        Runnable runnable;
      
        public CommonsTest(int threadNum,Runnable runnable) {
            this.runnable = runnable;
            this.threadNum = threadNum;  
            pool = Executors.newScheduledThreadPool(this.threadNum);  
      
        }  
        CommonsTest(int threadNum){  
            this(threadNum,null);  
        }  
        CommonsTest(Runnable runnable){
            this(5,runnable);
        }  
      
        public static CommonsTest create(){  
            return new CommonsTest(5);  
        }  
        public CommonsTest setThreadNum(int threadNum){  
            this.threadNum = threadNum;  
            return this;  
        }  
        public CommonsTest setApply(Runnable runnable){
            this.runnable = runnable;
            return this;
        }  
      
        public void start(){  
            for(int i = 0 ; i<threadNum;i ++ ){  
                pool.execute(new TestThread());  
            }  
            String format = "---------------------"+"当前1s内的执行数"+"/"+"总的执行数"+"/"+"平均的执行数"+"/"+"执行的时间"+"/"+"最长执行时间";  
            while(true){  
                try {  
                    x++;  
                    Thread.sleep(sleepTime);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                long nowtmp = now.get();  
                System.out.println(format);  
                System.out.println("---------------------"+(nowtmp - lastTimes)+"/"+now.intValue()+"/"+(now.intValue()/x)+"/"+x+"/"+maxTime.get()+"ms");  
                lastTimes = nowtmp;  
            }  
        }  
      
        class TestThread extends Thread{  
            public TestThread() {  
      
            }  
            @Override  
            public void run() {  
                System.out.println("start------------------"+Thread.currentThread().getName());  
                while (true){  
                    try {  
                        long start = System.currentTimeMillis();
                        runnable.run();
                        long end = System.currentTimeMillis() - start;
                        if(end>maxTime.get()){  
                            maxTime.set(end);  
                        }  
                        now.incrementAndGet();  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
      
                }  
            }
        }  
    }
    

             看到这个类,感觉和之前的模板类没啥区别,只是在具体的测试代码调用处从模版方法改成了接口方法。具体的使用也简单了n多。

    /**
     * Created by lsz on 14-10-24.
     */
    public class SimpleTest {
        public static void main(String[] args) {
            new CommonsTest(5,new Runable() {
                @Override
                public void run {
                    //这里写压力测试的逻辑代码
                    // 创建http请求(get方式)
                    // HttpGet httpget = new HttpGet("http://www.xxx.com/xxx");
                    //httpclient.execute(httpget);
                    return true;
                }
            }).start();
        }
    }
    

              在这里只需要关心线程数和业务逻辑了,不需要继承任何类,欢迎讨论。





    展开全文
  • Java压力测试工具

    千次阅读 2018-07-13 14:19:59
    Java压力测试工具

    Java的压力测试工具

    展开全文
  • java接口压力测试

    万次阅读 2017-05-09 21:23:54
    用apacheBench工作做压力测试时,总是报错,网上也一直找不到错误的原因。最后发现是接口中调用了公司的一个框架服务引起的,其他不调该服务的接口都正常。于是写了一个测试接口的工具类。实现的功能,参照apache...
  •  Apache JMeter是Apache组织开发的基于Java压力测试工具。用于对软件做压力测试,它最初被设计用于Web应用测试但后来扩展到其他测试领域。 它可以用于测试静态和动态资源例如静态文件、Java 小服务程序、CGI 脚本...
  • java代码线程压力测试

    千次阅读 2016-11-16 16:03:32
    //以下是测试方法,开始测试用这个 @Test public void TestTimeThread () { Date start = new Date(); ThreadTest t = new ThreadTest(); Date end = new Date(); int seconds = getSeconds...
  • java 自动化压力测试

    千次阅读 2019-03-07 16:56:18
     接口测试相对于UI测试来说测试成本低,相对稳定,变动不大,日常测试可使用postman、jmeter、python request,java模拟url等进行测试。  上次分享了一个python版本的自动化平台,趁着有空就做了一个java版本的...
  • 应用程序在chrome浏览器上运行,请问使用什么工具可以对该应用进行压力测试啊?
  • Java多线程做压力测试

    千次阅读 2018-06-05 11:27:47
    写一个多线程做压力测试的例子 public interface RequestHandler&lt;T&gt; { public void handle(T result); }   package com.arch; import java.util.ArrayList; import java.util.List; import ...
  • Jmeter接口测试+压力测试

    万次阅读 多人点赞 2017-05-14 14:01:50
    jmeter是apache公司基于java开发的一款开源压力测试工具,体积小,功能全,使用方便,是一个比较轻量级的测试工具,使用起来非常简单。因为jmeter是java开发的,所以运行的时候必须先要安装jdk才可以。jmeter是...
  • 记一次完整的java项目压力测试

    万次阅读 2018-07-27 10:57:04
    总结:通过这次压力测试,增加了对程序的理解;假定正常情况下方法执行时间为2秒,吞吐量为100/s,则并发为200/s;假设用户可接受范围为10s,那么并发量可以继续增加到1000/s,到这个时候一切还都正常,若想继续提高...
  • Java性能/负载/压力测试工具

    千次阅读 2012-07-04 10:44:23
    Java性能/负载/压力测试工具     1.LoadRunner:支持多种常用协议多且个别协议支持的版本比较高;可以设置灵活的负载压力测试方案,可视化的图形界面可以监控丰富的资
  • JAVA常用工具--JMeter压力测试工具

    千次阅读 2020-04-04 17:22:59
    Apache JMeter是Apache组织开发的基于Java压力测试工具。用于对软件做压力测试,它最初被设计用于Web应用测试,但后来扩展到其他测试领域。 它可以用于测试静态和动态资源,例如静态文件、Java 小服务程序、CGI ...
  • Java模拟并发操作进行压力测试代码
  • 使用java自定义jmeter的压力测试用例

    千次阅读 2014-12-19 15:12:26
    之前已经分享过如何用java进行压力测试,然而,那种直接用代码压测的缺乏图形化GUI的直观。同时,只能够单机进行压测,有些情况下,比如webservice的压测需要大量的序列化反序列化xml,这些很消耗CPU之类的资源的...
  • import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.HttpURLConnection; import java.net.URL...
  • Apache JMeter是Apache组织开发的基于Java压力测试工具。用于对软件做压力测试,它最初被设计用于Web应用测试,但后来扩展到其他测试领域。 二、JMeter安装 下载地址:http://jmeter-plugins.org/downloads/all/ ...
  • JMeter完成java请求的压力测试 原文地址:http://www.cnblogs.com/zhaoxd07/p/4895224.html 作者:KK_Yolanda 这篇文章已经写得比较全面了,所以转载下,自己懒得总结了。 先定义一下我说的remoteService:即远程...
  • Apache JMeter是Apache组织开发的基于Java压力测试工具。用于对软件做压力测试,它最初被设计用于Web应用测试但后来扩展到其他测试领域。 它可以用于测试静态和动态资源例如静态文件、Java 小服务程序、CGI 脚本、...
  • 如果想进行压力测试/并发测试,可以使用Java的多线程,下面是代码示例(部分代码引自网络) import java.sql.*; class RunnableDemo implements Runnable { private Thread t; private ...
  • 近来笔者写了翻牌抽奖游戏 为了测试中奖几率 笔者需要将抽奖接口跑大约2W+的中奖记录 ... ...Apache JMeter是Apache组织开发的基于Java压力测试工具。用于对软件做压力测试,它最初被设计用于
  • JMeter做压力测试教程及结果分析

    万次阅读 多人点赞 2019-02-15 16:55:52
    Apache JMeter是Apache组织开发的基于Java压力测试工具。用于对软件做压力测试,它最初被设计用于Web应用测试,但后来扩展到其他测试领域。 三、Java环境的安装与配置: (1)因为JMeter是使用JAVA写的,所以...
  • Java 模拟并发操作压力测试代码

    千次阅读 2016-09-19 17:36:41
    import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.HttpURLConnection;
  • 可以设置灵活的负载压力测试方案,可视化的图形界面可以监控丰富的资源;报告可以导出到Word、Excel以及HTML格式。 2. WebLoad:webload是RadView公司推出的一个性能测试和分析工具,它让web应用程序开发者自动执行...
  • 本篇博文是“Java秒杀系统实战系列文章”的第十二篇,本篇博文我们将借助压力测试工具Jmeter重现秒杀场景(高并发场景)下出现的各种典型的问题,其中最为经典的当属“商品库存超卖”的问题,在本文我们重现这种问题...
  • C语言编写的winsocket Vuser脚本比较常见和简单,Java由于第三方库的庞大,能做的事情很多,这里介绍一下用Java写的脚本模拟socket客户端的压力测试情况。 主要环境: 1,jkd1.6 2,LoadRunner11 3,ApacheMINA...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,879
精华内容 41,951
关键字:

java压力测试

java 订阅