架构师训练营第 0 期第 7 周作业

import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
public class HttpConnectionPool {
    /**
     * 最大连接数
     */
    private static final int MAX_CONNECTION_NUMBER = 100;
    /**
     * 连接超时，3000ms
     */
    private static final int CONNECT_TIMEOUT = 3000;
    /**
     * 请求处理超时，3000ms
     */
    private static final int SOCKET_TIMEOUT = 3000;
    private static final RequestConfig REQUEST_CONFIG = RequestConfig.custom()
            .setConnectTimeout(CONNECT_TIMEOUT)
            .setConnectionRequestTimeout(CONNECT_TIMEOUT)
            .setSocketTimeout(SOCKET_TIMEOUT)
            .build();
    private static PoolingHttpClientConnectionManager httpClientConnectionManager;
    private final CloseableHttpClient httpClient;
    public HttpConnectionPool(int concurrentNumber) {
        httpClientConnectionManager = new PoolingHttpClientConnectionManager();
        //设置连接参数
        // 最大连接数
        httpClientConnectionManager.setMaxTotal(MAX_CONNECTION_NUMBER);
        // 路由最大连接数
        httpClientConnectionManager.setDefaultMaxPerRoute(concurrentNumber);
        httpClient = HttpClients.custom().setConnectionManager(httpClientConnectionManager).build();
    }
    public CloseableHttpClient getHttpClient() {
        return httpClient;
    }
    /**
     * get请求
     *
     * @param requestUrl 请求URL
     * @return 响应结果
     */
    public String doGet(String requestUrl) {
        HttpGet httpGet = new HttpGet(requestUrl);
        httpGet.setConfig(REQUEST_CONFIG);
        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpGet);
            return EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return null;
    }
    /**
     * 测试完成，要记得关掉连接
     */
    public void close() {
        if (httpClient != null) {
            try {
                httpClient.close();
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
        if (httpClientConnectionManager != null) {
            httpClientConnectionManager.close();
        }
    }
}

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
public class ResponseTimeTest implements Callable<Long> {
    /**
     * Http连接池
     */
    private final HttpConnectionPool httpConnectionPool;
    /**
     * 请求URL
     */
    private final String requestUrl;
    /**
     * CountDownLatch，用来记录次数
     */
    private final CountDownLatch countDownLatch;
    public ResponseTimeTest(CountDownLatch countDownLatch,
                            HttpConnectionPool httpConnectionPool,
                            String requestUrl) {
        this.countDownLatch = countDownLatch;
        this.httpConnectionPool = httpConnectionPool;
        this.requestUrl = requestUrl;
    }
    @Override
    public Long call() throws Exception {
        long startTime = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
        httpConnectionPool.doGet(requestUrl);
        long responseTime = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli() - startTime;
        countDownLatch.countDown();
        return responseTime;
    }
}

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
public class PerformanceTestTool {
    /**
     * 请求URL
     */
    private final String requestUrl;
    /**
     * 请求次数
     */
    private final Integer requestTotal;
    /**
     * 并发数量
     */
    private final Integer concurrent;
    private final HttpConnectionPool httpConnectionPool;
    private final ExecutorService executorService;
    private final List<Long> responseTimes = new ArrayList<>();
    public PerformanceTestTool(String requestUrl, Integer requestTotal, Integer concurrent) {
        this.requestUrl = requestUrl;
        this.requestTotal = requestTotal;
        this.concurrent = concurrent;
        this.httpConnectionPool = new HttpConnectionPool(concurrent);
        this.executorService = Executors.newFixedThreadPool(concurrent);
    }
    public void test() throws Exception {
        int requestTime = requestTotal / concurrent;
        for (int i = 0; i < requestTime; i++) {
            concurrentTest();
        }
        httpConnectionPool.close();
        // 压测完成连接池需要关闭
        executorService.shutdown();
    }
    private void concurrentTest() throws Exception {
        // 每次并发为10
        CountDownLatch countDownLatch = new CountDownLatch(concurrent);
        for (int i = 0; i < concurrent; i++) {
            Future<Long> future = executorService.submit(new ResponseTimeTest(countDownLatch, httpConnectionPool, requestUrl));
            responseTimes.add(future.get());
        }
        countDownLatch.await();
    }
    /**
     * 获取本次性能测试平均时间
     *
     * @return 平均时间
     */
    public double getAverageTime() {
        double averageTime = responseTimes.stream().mapToLong(Long::longValue).average().orElse(0);
        return BigDecimal.valueOf(averageTime).setScale(2, RoundingMode.FLOOR).doubleValue();
    }
    /**
     * 获取本次性能测试TP95时间
     * TP95 就是把请求时间 从小到大 排序，在排序中95%的值，
     * 如果请求100次，TP95就是排序95的值；果请求1000次，TP95就是排序950的值
     *
     * @return 平均时间
     */
    public Long getTp95() {
        List<Long> sortResponseTimes = responseTimes.stream().sorted(Comparator.comparing(Long::longValue)).collect(Collectors.toList());
        int percent95 = BigDecimal.valueOf(sortResponseTimes.size() * 0.95).setScale(0, RoundingMode.FLOOR).intValue();
        return sortResponseTimes.get(percent95);
    }
    public static void main(String[] args) throws Exception {
        PerformanceTestTool performanceTestTool =
                new PerformanceTestTool("https://www.baidu.com", 100, 10);
        performanceTestTool.test();
        System.out.println("Request Total : " + performanceTestTool.responseTimes.size());
        System.out.println("Request Times : " + performanceTestTool.responseTimes);
        System.out.println("Average Time : " + performanceTestTool.getAverageTime());
        System.out.println("TP95 : " + performanceTestTool.getTp95());
    }
}