架构师训练 第七周 作业

/**
 * TestCase 模板
 *
 * @author Lee
 * @date 2020/7/21 16:20
 */
public abstract class BaseTestCase implements Callable {
    /**
     * case 执行抽象方法
     *
     * @return
     */
    public abstract Result execution();
}

/**
 * 测试case类
 * @author Lee
 */
public class TestGetRequest extends BaseTestCase {
    /**
     * 测试用 url
     */
    private String url;
    public TestGetRequest(String url) {
        this.url = url;
    }
    /**
     * 请求执行
     *
     * @return  Result
     */
    @Override
    public Result execution() {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 创建Get请求
        HttpGet httpGet = new HttpGet(this.url);
        long t1 = System.currentTimeMillis();
        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpGet);
        } catch (IOException e) {
            e.printStackTrace();
        }
        long t2 = 0L;
        Result result = new Result();
        // 访问成功
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            t2 = System.currentTimeMillis();
            result.setResponseTime(t2 -t1);
            result.setSuccess(true);
        }
        // 访问失败
        else {
            t2 = System.currentTimeMillis();
            result.setResponseTime(t2 -t1);
            result.setSuccess(false);
        }
        return result;
    }
    @Override
    public Object call() throws Exception {
        return execution();
    }
}

/**
 * 测试返回结果
 *
 * @author Lee
 * @date 2020/7/21 9:00
 */
public class Result {
    /**
     * 响应时间
     */
    private Long responseTime;
    /**
     * 访问是否成功
     */
    private boolean success;
    public Long getResponseTime() {
        return responseTime;
    }
    public void setResponseTime(Long responseTime) {
        this.responseTime = responseTime;
    }
    public boolean isSuccess() {
        return success;
    }
    public void setSuccess(boolean success) {
        this.success = success;
    }
}

/**
 * 测试报告模板
 *
 * @author rikun
 */
public abstract class BaseTestReport {
    /**
     * 测试报告生成
     *
     * @param results
     */
    public abstract void calResult(List<Future<Result>> results);
}

/**
 * 测试报告
 *
 * @author Lee
 * @date 2020/7/21 8:43
 */
public class TestReport extends BaseTestReport {
    private int numberOfTests;
    public TestReport(int numOfTests) {
        this.numberOfTests = numOfTests;
    }
    /**
     * 计算出测试结果
     *
     * @param results
     * @return
     */
    @Override
    public void calResult(List<Future<Result>> results) {
        // 取出每次的请求的响应时间
        List<Long> list = new ArrayList<>();
        try{
            for (Future<Result> item: results) {
                Result result = item.get();
                list.add(result.getResponseTime());
            }
        } catch (ExecutionException | InterruptedException ignored) {
            ignored.printStackTrace();
        }
        // 按大小排序
        list.sort(Comparator.comparingLong(Long:: longValue));
        // 求 95% 响应时间 序号
        int ninetyFiveRT = BigDecimal.valueOf(numberOfTests).multiply(BigDecimal.valueOf(0.95D)).setScale(0, BigDecimal.ROUND_UP).intValue();
        // 求 平均响应时间
        double avgRt = list.stream().mapToLong(Long::longValue).average().getAsDouble();
        // 打印出测试结果
        System.out.println("平均响应时间: " + BigDecimal.valueOf(avgRt).setScale(0, BigDecimal.ROUND_UP) + ";");
        System.out.println("95%响应时间： " + list.get(ninetyFiveRT) + ";");
    }
}

/**
 * 任务设定
 *
 * @author rikun
 */
public class TaskConfiguration {
    /**
     * 并发数
     */
    private int concurrentNum;
    /**
     * 批次数
     */
    private int numberOfTests;
    /**
     * 线程池
     */
    private ExecutorService pool;
    /**
     * 测试类型
     */
    private BaseTestCase testCase;
    /**
     * 测试报告
     */
    private BaseTestReport testReport;
    /**
     * 测试计划配置
     *
     * @param concurrentNum int
     * @param numberOfTests int
     */
    public TaskConfiguration(int concurrentNum, int numberOfTests) {
        this.concurrentNum = concurrentNum;
        this.numberOfTests = numberOfTests;
        this.pool = new ThreadPoolExecutor(numberOfTests,
                                            numberOfTests,
                                            0,
                                            TimeUnit.SECONDS,
                                            new SynchronousQueue<Runnable>(),
                                            Executors.defaultThreadFactory(),
                                            new ThreadPoolExecutor.AbortPolicy());
    }
    /**
     * 设置测试case
     *
     * @param testCase
     */
    public void setTestCase(BaseTestCase testCase) {
        this.testCase = testCase;
    }
    /**
     * 设置测试报告
     *
     * @param testReport
     */
    public void setTestReport(BaseTestReport testReport) {
        this.testReport = testReport;
    }
    /**
     * 多批次执行
     *
     * @throws InterruptedException
     */
    public void testExecute() throws InterruptedException {
        if (this.testCase == null) {
            System.out.println("请设定测试case,否则测试无法进行");
            return;
        }
        BigDecimal val1 = BigDecimal.valueOf(concurrentNum);
        BigDecimal val2 = BigDecimal.valueOf(numberOfTests);
        int result = val2.divide(val1, BigDecimal.ROUND_UP).intValue();
        List<Future<Result>> results = new ArrayList<>();
        // 将请求分批发送
        for (int i = 0; i< result; i++) {
            int size = concurrentNum;
            if ( i+1 == result) {
                size = numberOfTests - (concurrentNum * i);
            }
            results.addAll(singleExecution(size));
        }
        // 释放资源
        pool.shutdown();
        if (this.testReport == null) {
            System.out.println("请设定测试报告，否则无法查看测试结果");
        }
        else {
            this.testReport.calResult(results);
        }
    }
    /**
     * 单批次执行
     *
     * @throws InterruptedException
     */
    private List<Future<Result>> singleExecution(int size) throws InterruptedException {
        List<Callable<Result>> tasks = new ArrayList<>();
        for (int i = 0; i< size; i++) {
            tasks.add(this.testCase);
        }
        // 批量执行任务
        return pool.invokeAll(tasks);
    }
}

/**
 * 执行测试
 *
 * @author Lee
 */
public class Client {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int numberOfTests = 100;
        // 测试的并发数，请求数 设定
        TaskConfiguration taskExecution =
                new TaskConfiguration(10,
                                        numberOfTests);
        // 设定测试case
        taskExecution.setTestCase(new TestGetRequest("http://www.baidu.com"));
        // 设定测试报告
        taskExecution.setTestReport(new TestReport(numberOfTests));
        // 执行测试计划
        taskExecution.testExecute();
    }
}

平均响应时间: 27;
95%响应时间： 67;