您的位置: 首页  >  文章  >  轻松把玩HttpClient之封装HttpClient工具类(八)，优化启用Http连接池策略

轻松把玩HttpClient之封装HttpClient工具类(八)，优化启用Http连接池策略

分类: 文章 • 2024-10-25 22:59:46

https://blog.****.net/xiaoxian8023/article/details/53064210


  1. /** 
  2.  * HCB对象，用于创建HttpClient对象 
  3.  */  
  4. private HCB hcb;  
  5.   
  6. public HCB hcb() {  
  7.     return hcb;  
  8. }  
  9.   
  10. /** 
  11.  * HCB对象，用于自动从连接池中获得HttpClient对象<br> 
  12.  * <font color="red"><b>请调用hcb.pool方法设置连接池</b></font> 
  13.  * @throws HttpProcessException  
  14.  */  
  15. public HttpConfig hcb(HCB hcb) throws HttpProcessException {  
  16.     this.hcb = hcb;  
  17.     return this;  
  18. }  
[java] view plain copy
  1. /** 
  2.  * 判定是否开启连接池、及url是http还是https <br> 
  3.  *      如果已开启连接池，则自动调用build方法，从连接池中获取client对象<br> 
  4.  *      否则，直接返回相应的默认client对象<br> 
  5.  *  
  6.  * @throws HttpProcessException  
  7.  */  
  8. private static void create(HttpConfig config) throws HttpProcessException  {  
  9.     if(config.hcb()!=null && config.hcb().isSetPool){ //如果设置了hcb对象，且配置了连接池，则直接从连接池取  
  10.         if(config.url().toLowerCase().startsWith("https://")){  
  11.             config.client(config.hcb().ssl().build());  
  12.         }else{  
  13.             config.client(config.hcb().build());  
  14.         }  
  15.     }else{  
  16.         if(config.client()==null){//如果为空，设为默认client对象  
  17.             if(config.url().toLowerCase().startsWith("https://")){  
  18.                 config.client(client4HTTPS);  
  19.             }else{  
  20.                 config.client(client4HTTP);  
  21.             }  
  22.         }  
  23.     }  
  24. }  
       至于关闭方面，fmt2String以及fmt2Stream方法中，在EntityUtils.toString和EntityUtils.consume方法中已经close了instream，释放了资源。最后调用close(HttpClient)即执行client.close()方法。这样就不会直接关闭链接了，会被连接池自动回收再次使用。

       最后分享一个测试类，分组测试Get请求、Down操作，在开启和关闭Http线程池完成请求的耗时情况。代码如下：
[java] view plain copy
  1. import java.io.File;  
  2. import java.io.FileNotFoundException;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.util.Arrays;  
  6. import java.util.List;  
  7. import java.util.concurrent.CountDownLatch;  
  8. import java.util.concurrent.ExecutorService;  
  9. import java.util.concurrent.Executors;  
  10.   
  11. import org.apache.http.Header;  
  12.   
  13. import com.tgb.ccl.http.common.HttpConfig;  
  14. import com.tgb.ccl.http.common.HttpHeader;  
  15. import com.tgb.ccl.http.exception.HttpProcessException;  
  16. import com.tgb.ccl.http.httpclient.HttpClientUtil;  
  17. import com.tgb.ccl.http.httpclient.builder.HCB;  
  18.   
  19. /** 
  20.  * 测试启用http连接池 
  21.  *  
  22.  * @author arron 
  23.  * @date 2016年11月7日 下午1:08:07  
  24.  * @version 1.0 
  25.  */  
  26. public class TestHttpPool {  
  27.       
  28.     // 设置header信息  
  29.     private static final Header[] headers = HttpHeader.custom().userAgent("Mozilla/5.0").from("http://blog.****.net/newest.html").build();  
  30.       
  31.     // URL列表数组，GET请求  
  32.     private static final String[] urls = {  
  33.             "http://blog.****.net/xiaoxian8023/article/details/49883113",  
  34.             "http://blog.****.net/xiaoxian8023/article/details/49909359",  
  35.             "http://blog.****.net/xiaoxian8023/article/details/49910127",  
  36.             "http://blog.****.net/xiaoxian8023/article/details/49910885",  
  37.             "http://blog.****.net/xiaoxian8023/article/details/51606865",  
  38.     };  
  39.       
  40.     // 图片URL列表数组，Down操作  
  41.     private static final String[] imgurls ={  
  42.             "http://ss.bdimg.com/static/superman/img/logo/logo_white_fe6da1ec.png",  
  43.             "https://scontent-hkg3-1.xx.fbcdn.net/hphotos-xaf1/t39.2365-6/11057093_824152007634067_1766252919_n.png"  
  44.     };  
  45.       
  46.     private static StringBuffer buf1=new StringBuffer();  
  47.     private static StringBuffer buf2=new StringBuffer();  
  48.       
  49.     //多线程get请求  
  50.     public static void testMultiGet(HttpConfig cfg, int count) throws HttpProcessException{  
  51.             try {  
  52.                 int pagecount = urls.length;  
  53.                 ExecutorService executors = Executors.newFixedThreadPool(pagecount);  
  54.                 CountDownLatch countDownLatch = new CountDownLatch(count);     
  55.                 //启动线程抓取  
  56.                 for(int i = 0; i< count;i++){  
  57.                     executors.execute(new GetRunnable(countDownLatch,cfg.headers(headers).url(urls[i%pagecount])));  
  58.                 }  
  59.                 countDownLatch.await();  
  60.                 executors.shutdown();  
  61.             } catch (InterruptedException e) {  
  62.                 e.printStackTrace();  
  63.             }  
  64.     }  
  65.       
  66.     //多线程下载  
  67.     public static void testMultiDown(HttpConfig cfg, int count) throws HttpProcessException{  
  68.         try {  
  69.             int pagecount = imgurls.length;  
  70.             ExecutorService executors = Executors.newFixedThreadPool(pagecount);  
  71.             CountDownLatch countDownLatch = new CountDownLatch(count);     
  72.             //启动线程抓取  
  73.             for(int i = 0; i< count;i++){  
  74.                 executors.execute(new GetRunnable(countDownLatch, cfg.url(imgurls[i%2]), new FileOutputStream(new File("d://aaa//"+(i+1)+".png"))));  
  75.             }  
  76.             countDownLatch.await();  
  77.             executors.shutdown();  
  78.         } catch (FileNotFoundException e) {  
  79.             e.printStackTrace();  
  80.         } catch (InterruptedException e) {  
  81.             e.printStackTrace();  
  82.         }  
  83.     }  
  84.       
  85.      static class GetRunnable implements Runnable {  
  86.             private CountDownLatch countDownLatch;  
  87.             private HttpConfig config = null;  
  88.             private FileOutputStream out = null;  
  89.   
  90.             public GetRunnable(CountDownLatch countDownLatch,HttpConfig config){  
  91.                this(countDownLatch, config, null);  
  92.             }  
  93.             public GetRunnable(CountDownLatch countDownLatch,HttpConfig config,FileOutputStream out){  
  94.                 this.countDownLatch = countDownLatch;  
  95.                 this.config = config;  
  96.                 this.out = out;  
  97.             }  
  98.               
  99.             @Override  
  100.             public void run() {  
  101.                 try {  
  102.                     config.out(out);  
  103.                     if(config.out()==null){  
  104.                         String response = null;  
  105.                         response =  HttpClientUtil.get(config);  
  106.                         System.out.println(Thread.currentThread().getName()+"--获取内容长度："+response.length());  
  107.                         response = null;  
  108.   
  109.                     }else{  
  110.                         HttpClientUtil.down(config);  
  111.                         try {  
  112.                             config.out().flush();  
  113.                             config.out().close();  
  114.                         } catch (IOException e) {  
  115.                             e.printStackTrace();  
  116.                         }  
  117.                         System.out.println(Thread.currentThread().getName()+"--下载完毕");  
  118.                     }  
  119.                 } catch (HttpProcessException e) {  
  120.                     e.printStackTrace();  
  121.                 } finally {  
  122.                     countDownLatch.countDown();  
  123.                 }  
  124.             }  
  125.         }    
  126.   
  127.   
  128.     /** 
  129.      * 测试不启用http连接池，get100次，down20次的执行时间 
  130.      * @throws HttpProcessException 
  131.      */  
  132.     private static void testNoPool(int getCount, int downCount) throws HttpProcessException {  
  133.         long start = System.currentTimeMillis();  
  134.   
  135.         if(getCount>0){  
  136.             HttpConfig cfg1 = HttpConfig.custom().client(HCB.custom().build()).headers(headers);  
  137.             testMultiGet(cfg1, getCount);  
  138.         }  
  139.         if(downCount>0){  
  140.             HttpConfig cfg2 = HttpConfig.custom().client(HCB.custom().build());  
  141.             testMultiDown(cfg2, downCount);  
  142.         }  
  143.           
  144.         System.out.println("-----所有线程已完成！------");  
  145.         long end = System.currentTimeMillis();  
  146.         System.out.println("总耗时（毫秒）： -> " + (end - start));  
  147.         buf1.append("\t").append((end-start));  
  148.     }  
  149.   
  150.       
  151.     /** 
  152.      * 测试启用http连接池，get100次，down20次的执行时间 
  153.      * @throws HttpProcessException 
  154.      */  
  155.     private static void testByPool(int getCount, int downCount) throws HttpProcessException {  
  156.         long start = System.currentTimeMillis();  
  157.           
  158.         HCB hcb= HCB.custom().timeout(10000).pool(10, 10).ssl();  
  159.           
  160.         if(getCount>0){  
  161.             HttpConfig cfg3 = HttpConfig.custom().hcb(hcb);  
  162.             testMultiGet(cfg3, getCount);  
  163.         }  
  164.         if(downCount>0){  
  165.             HttpConfig cfg4 = HttpConfig.custom().hcb(hcb);  
  166.             testMultiDown(cfg4, downCount);  
  167.         }  
  168.   
  169.         System.out.println("-----所有线程已完成！------");  
  170.         long end = System.currentTimeMillis();  
  171.         System.out.println("总耗时（毫秒）： -> " + (end - start));  
  172.         buf2.append("\t").append((end-start));  
  173.     }  
  174.       
  175.     public static void main(String[] args) throws Exception {  
  176.         File file = new File("d://aaa");  
  177.         if(!file.exists() && file.isDirectory()){  
  178.             file.mkdir();  
  179.         }  
  180.           
  181.         //-------------------------------------------  
  182.         //  以下2个方法  
  183.         //  分别测试 （get次数，down次数）   
  184.         //  {100,0},{200,0},{500,0},{1000,0}  
  185.         //  {0,10},{0,20},{0,50},{0,100}  
  186.         //  {100,10},{200,20},{500,50},{1000,100}  
  187.         //-------------------------------------------  
  188.           
  189.         int[][] times1 = {{100,0} ,{ 200,0 },{ 500,0 },{ 1000,0}};  
  190.         int[][] times2 = {{0,10},{0,20},{0,50},{0,100}};  
  191.         int[][] times3 = {{100,10},{200,20},{500,50},{1000,100}};  
  192.         List<int[][]> list = Arrays.asList(times1,times2,times3);  
  193.         int n=5;  
  194.           
  195.         int t=0;  
  196.         //测试未启用http连接池，  
  197.         for (int[][] time : list) {  
  198.             buf1.append("\n");  
  199.             for (int i = 0; i < time.length; i++) {  
  200.                 for (int j = 0; j < n; j++) {  
  201.                     testNoPool(time[i][0],time[i][1]);  
  202.                     Thread.sleep(100);  
  203.                     System.gc();  
  204.                     Thread.sleep(100);  
  205.                 }  
  206.                 buf1.append("\n");  
  207.             }  
  208.         }  
  209.   
  210.         t=0;  
  211.         //测试启用http连接池  
  212.         for (int[][] time : list) {  
  213.             buf2.append("\n");  
  214.             for (int i = 0; i < time.length; i++) {  
  215.                 for (int j = 0; j < n; j++) {  
  216.                     testByPool(time[i][0],time[i][1]);  
  217.                     Thread.sleep(100);  
  218.                     System.gc();  
  219.                     Thread.sleep(100);  
  220.                 }  
  221.                 buf2.append("\n");  
  222.             }  
  223.             t++;  
  224.         }  
  225.           
  226.         //把结果打印到Console中  
  227.         String[] results1 = buf1.toString().split("\n");  
  228.         String[] results2 = buf2.toString().split("\n");  
  229.           
  230.         for (int i = 0; i < results1.length; i++) {  
  231.             System.out.println(results1[i]);  
  232.             System.out.println(results2[i]);  
  233.         }  
  234.           
  235.     }  
  236. }  
       测试结果如下：
操作 请求次数 是否启用Pool 第1次 第2次 第3次 第4次 第5次 平均时间 启用后的效率
GET 100 无 4801 4807 4853 4810 4522 4758.6 52.89%
是 2146 1989 2302 2355 2416 2241.6
200 无 9222 9519 9085 9196 8908 9186 43.15%
是 4992 4711 4863 7001 4545 5222.4
500 无 23727 23082 23762 23427 23117 23423 45.88%
是 12146 12557 12581 13121 12979 12676.8
1000 无 47518 72445 45028 52860 55764 54723 48.62%
是 25073 25067 39550 26014 24888 28118.4
Down 10 无 10605 8273 9440 7774 8740 8966.4 4.37%
是 10415 7249 7331 8554 9325 8574.8
20 无 17306 18455 18811 19294 15430 17859.2 2.67%
是 17234 16028 18152 17530 17971 17383
50 无 46873 41528 51085 49900 40666 46010.4 -2.93%
是 44941 50376 46759 43774 50951 47360.2
100 无 89909 93065 98297 88440 92010 92344.2 -0.93%
是 91420 96388 94635 88424 95152 93203.8
GET,Down 100,10 无 15913 13465 14167 15607 11566 14143.6 27.42%
是 11805 10800 8322 10735 9668 10266
200,20 无 26579 28744 27791 29712 32360 29037.2 25.76%
是 20891 24664 19319 19511 23394 21555.8
500,50 无 71462 72694 74285 76207 72574 73444.4 13.46%
是 57137 75860 63288 62309 59192 63557.2
1,000,100 无 147264 149527 143251 143865 139723 144726 16.14%
是 118305 124517 122511 116823 124673 121365.8
测试使用时间（不含暂停和GC时间）、平均效率 79.1789833 23.04%

轻松把玩HttpClient之封装HttpClient工具类(八)，优化启用Http连接池策略
轻松把玩HttpClient之封装HttpClient工具类(八)，优化启用Http连接池策略

       通过测试结果可以看出来，Get请求效果明显，启用后性能要提升50%左右。而Down操作，则反而有所下降。这是为什么呢？其实很简单。连接池是节省了握手的次数，但是握手所消耗的时间，跟一个Down操作相比，肯定要小很多。所以Down操作消耗的时间已经超过了节省握手的时间了，也就起不到优化的作用了，所以要根据实际情况使用连接池。

       最新的完整代码请到GitHub上进行下载：https://github.com/Arronlong/httpclientUtil 。


相关推荐