百度360必应搜狗淘宝本站头条
vba高级教程svn连接scheduledtaskmybatis plus结构体数组
当前位置：网站首页 > 编程网 > 正文

手撸了一个网络请求工具类，开发速度迅速提升了300%

yuyutoo 2024-10-12 01:24 7 浏览 0 评论

一、简介

在上一篇文章中，我们详细的介绍了RestTemplate工具类的用法，相比直接使用Apache的HttpClient进行网络传输，采用RestTemplate开发代码确实简化了很多，甚至可以做到傻瓜式操作，但是基于当前的团队人员开发习惯，我们可不可以继续基于RestTemplate再做一层封装呢？以便于操作Http网络请求，更加简单、便捷！

答案是肯定的！

本文要介绍的这个工具类，就是小编基于RestTemplate做了一层代码封装，里面涵盖了GET、POST、PUT、DELETE、文件上传与下载等等方法，同时支持自定义头部传参，通过灵活的传参，可以满足绝大部分业务场景下的网络请求场景！

同时，在上一篇介绍RestTemplate的《真不是我吹，Spring里这款牛逼的网络工具库我估计你都没用过！》文章里，我们还漏掉了一个最常用的场景，假如返回的对象，是一个范型类型，该怎么处理？

在本篇的文章里，我们也会详细的介绍这种问题的处理方法！

废话也不多说，直接上代码，希望对网友们能有所帮助！

二、代码实践

下面以SpringBoot项目为例，如果是Spring项目，操作也类似，在配置类初始化的时候，实例化一个RestTemplate。

  • 首先添加httpclient依赖包，作为RestTemplate底层客户端
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.6</version>
</dependency>
  • 接着创建一个配置，初始化RestTemplate
@Configuration
public class HttpConfiguration {


    /**
     * 没有实例化RestTemplate时，初始化RestTemplate
     * @return
     */
    @ConditionalOnMissingBean(RestTemplate.class)
    @Bean
    public RestTemplate restTemplate(){
        RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory());
        return restTemplate;
    }

    /**
     * 使用HttpClient作为底层客户端
     * @return
     */
    private ClientHttpRequestFactory getClientHttpRequestFactory() {
        int timeout = 5000;
        RequestConfig config = RequestConfig.custom()
                .setConnectTimeout(timeout)
                .setConnectionRequestTimeout(timeout)
                .setSocketTimeout(timeout)
                .build();
        CloseableHttpClient client = HttpClientBuilder
                .create()
                .setDefaultRequestConfig(config)
                .build();
        return new HttpComponentsClientHttpRequestFactory(client);
    }
}
  • 然后，创建一个HttpTemplate工具类，将其生命周期交给Spring管理
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RequestCallback;
import org.springframework.web.client.ResponseExtractor;
import org.springframework.web.client.RestTemplate;

import java.net.URI;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;

@Component
public class HttpTemplate {

    private static final Logger log = LoggerFactory.getLogger(HttpTemplate.class);


    @Autowired
    private RestTemplate restTemplate;

    /**
     * get请求，返回响应实体（响应业务对象不支持范型）
     * 支持restful风格
     * @param url
     * @param headers
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> T get(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables){
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.GET, new HttpEntity<>(createHeaders(headers)), responseType, uriVariables);
        return buildResponse(rsp);
    }


    /**
     * get请求，返回响应实体（响应业务对象支持范型）
     * 支持restful风格
     * @param url
     * @param headers
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> T get(String url, Map<String, String> headers, ParameterizedTypeReference<T> responseType, Object... uriVariables){
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.GET, new HttpEntity<>(createHeaders(headers)), responseType, uriVariables);
        return buildResponse(rsp);
    }

    /**
     * post请求，form表单提交（响应业务对象不支持范型）
     * 支持restful风格
     * @param url
     * @param headers
     * @param paramMap
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> T postByFrom(String url, Map<String, String> headers, Map<String, Object> paramMap, Class<T> responseType, Object... uriVariables){
        //指定请求头为表单类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.POST, new HttpEntity<>(createBody(paramMap), httpHeaders), responseType, uriVariables);
        return buildResponse(rsp);
    }

    /**
     * post请求，form表单提交（响应业务对象支持范型）
     * 支持restful风格
     * @param url
     * @param headers
     * @param paramMap
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> T postByFrom(String url, Map<String, String> headers, Map<String, Object> paramMap, ParameterizedTypeReference<T> responseType, Object... uriVariables){
        //指定请求头为表单类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.POST, new HttpEntity<>(createBody(paramMap), httpHeaders), responseType, uriVariables);
        return buildResponse(rsp);
    }


    /**
     * post请求，json提交（响应业务对象不支持范型）
     * 支持restful风格
     * @param url
     * @param headers
     * @param request
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> T postByJson(String url, Map<String, String> headers, Object request, Class<T> responseType, Object... uriVariables){
        //指定请求头为json类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.POST, new HttpEntity<>(request, httpHeaders), responseType, uriVariables);
        return buildResponse(rsp);
    }

    /**
     * post请求，json提交（响应业务对象支持范型）
     * 支持restful风格
     * @param url
     * @param headers
     * @param request
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> T postByJson(String url, Map<String, String> headers, Object request, ParameterizedTypeReference<T> responseType, Object... uriVariables){
        //指定请求头为json类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.POST, new HttpEntity<>(request, httpHeaders), responseType, uriVariables);
        return buildResponse(rsp);
    }

    /**
     * post请求，json提交，重定项
     * 支持restful风格
     * @param url
     * @param headers
     * @param request
     * @param uriVariables
     * @return
     */
    public String postForLocation(String url, Map<String, String> headers, Object request, Object... uriVariables){
        //指定请求头为json类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
        URI uri = restTemplate.postForLocation(url, new HttpEntity<>(request, httpHeaders), uriVariables);
        if(Objects.nonNull(uri)){
            return uri.toString();
        }
        return null;
    }

    /**
     * put请求，json提交（响应业务对象不支持范型）
     * @param url
     * @param headers
     * @param request
     * @param uriVariables
     */
    public <T> T put(String url, Map<String, String> headers, Object request, Class<T> responseType, Object... uriVariables){
        //指定请求头为json类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.PUT, new HttpEntity<>(request, httpHeaders), responseType, uriVariables);
        return buildResponse(rsp);
    }

    /**
     * put请求，json提交（响应业务对象支持范型）
     * @param url
     * @param headers
     * @param request
     * @param uriVariables
     */
    public <T> T put(String url, Map<String, String> headers, Object request, ParameterizedTypeReference<T> responseType, Object... uriVariables){
        //指定请求头为json类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.PUT, new HttpEntity<>(request, httpHeaders), responseType, uriVariables);
        return buildResponse(rsp);
    }


    /**
     * delete请求（响应业务对象不支持范型）
     * @param url
     * @param headers
     * @param uriVariables
     * @return
     */
    public <T> T delete(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables){
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.DELETE, new HttpEntity<>(createHeaders(headers)), responseType, uriVariables);
        return buildResponse(rsp);
    }

    /**
     * delete请求（响应业务对象支持范型）
     * @param url
     * @param headers
     * @param uriVariables
     * @return
     */
    public <T> T delete(String url, Map<String, String> headers, ParameterizedTypeReference<T> responseType, Object... uriVariables){
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.DELETE, new HttpEntity<>(createHeaders(headers)), responseType, uriVariables);
        return buildResponse(rsp);
    }


    /**
     * post请求，文件表单上传提交（响应业务对象不支持范型）
     * 支持restful风格
     * @param url
     * @param headers
     * @param paramMap
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> T uploadFile(String url, Map<String, String> headers, MultiValueMap<String, Object> paramMap, Class<T> responseType, Object... uriVariables){
        //指定请求头为文件&表单类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.POST, new HttpEntity<>(paramMap, httpHeaders), responseType, uriVariables);
        return buildResponse(rsp);
    }


    /**
     * post请求，文件表单上传提交（响应业务对象支持范型）
     * 支持restful风格
     * @param url
     * @param headers
     * @param paramMap
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> T uploadFile(String url, Map<String, String> headers, MultiValueMap<String, Object> paramMap, ParameterizedTypeReference<T> responseType, Object... uriVariables){
        //指定请求头为文件&表单类型
        HttpHeaders httpHeaders = createHeaders(headers);
        httpHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
        ResponseEntity<T> rsp = commonExchange(url, HttpMethod.POST, new HttpEntity<>(paramMap, httpHeaders), responseType, uriVariables);
        return buildResponse(rsp);
    }


    /**
     * 下载文件
     * @param url
     * @param headers
     * @param uriVariables
     * @return
     */
    public byte[] downloadFile(String url, Map<String, String> headers, Object... uriVariables){
        ResponseEntity<byte[]> rsp = commonExchange(url, HttpMethod.GET, new HttpEntity<>(createHeaders(headers)), byte[].class, uriVariables);
        return buildResponse(rsp);
    }


    /**
     * 下载大文件
     * @param url
     * @param headers
     * @param responseExtractor
     * @param uriVariables
     */
    public void downloadBigFile(String url, Map<String, String> headers, ResponseExtractor responseExtractor, Object... uriVariables){
        RequestCallback requestCallback = request -> {
            //指定请求头信息
            request.getHeaders().addAll(createHeaders(headers));
            //定义请求头的接收类型
            request.getHeaders().setAccept(Arrays.asList(MediaType.APPLICATION_OCTET_STREAM, MediaType.ALL));
        };
        restTemplate.execute(url, HttpMethod.GET, requestCallback,responseExtractor, uriVariables);
    }


    /**
     * 公共http请求方法（响应业务对象不支持范型）
     * @param url
     * @param method
     * @param requestEntity
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> ResponseEntity<T> commonExchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables){
        return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
    }


    /**
     * 公共http请求方法（响应业务对象支持范型）
     * @param url
     * @param method
     * @param requestEntity
     * @param responseType
     * @param uriVariables
     * @param <T>
     * @return
     */
    public <T> ResponseEntity<T> commonExchange(String url, HttpMethod method, HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Object... uriVariables){
        return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
    }



    /**
     * 封装头部参数
     * @param headers
     * @return
     */
    private HttpHeaders createHeaders(Map<String, String> headers){
        return new HttpHeaders(){{
            if(headers != null && !headers.isEmpty()){
                headers.entrySet().forEach(item -> {
                    set(item.getKey(), item.getValue());
                });
            }
        }};
    }


    /**
     * 封装请求体
     * @param paramMap
     * @return
     */
    private MultiValueMap<String, Object> createBody(Map<String, Object> paramMap){
        MultiValueMap<String, Object> valueMap = new LinkedMultiValueMap<>();
        if(paramMap != null && !paramMap.isEmpty()){
            paramMap.entrySet().forEach(item -> {
                valueMap.add(item.getKey(), item.getValue());
            });
        }
        return valueMap;
    }

    /**
     * 返回响应对象
     * @param rsp
     * @param <T>
     * @return
     */
    private <T> T buildResponse(ResponseEntity<T> rsp){
        if(!rsp.getStatusCode().is2xxSuccessful()){
            throw new RuntimeException(rsp.getStatusCode().getReasonPhrase());
        }
        return rsp.getBody();
    }
}
  • 最后，我们来做一下单元测试，使用案例如下，接口api还是基于上篇文章提供的服务
@RunWith(SpringRunner.class)
@SpringBootTest
public class HttpControllerJunit {


    @Autowired
    private HttpTemplate httpTemplate;


    /**
     * get请求测试
     */
    @Test
    public void testGet(){
        //请求地址
        String url = "http://localhost:8080/testGet";

        //发起请求,直接返回对象
        ResponseBean responseBean = httpTemplate.get(url, createHeader("get"), ResponseBean.class);
        System.out.println(responseBean.toString());
    }

    /**
     * get请求测试，restful风格
     */
    @Test
    public void testGetByRestFul(){
        //请求地址
        String url = "http://localhost:8080/testGetByRestFul/{1}";

        //发起请求,直接返回对象（restful风格）
        ResponseBean responseBean = httpTemplate.get(url, createHeader("testGetByRestFul"), ResponseBean.class, "张三");
        System.out.println(responseBean.toString());
    }


    /**
     * 模拟表单提交，post请求
     */
    @Test
    public void testPostByForm(){
        //请求地址
        String url = "http://localhost:8080/testPostByFormAndObj";

        //表单参数
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("userName", "唐三藏");
        paramMap.put("userPwd", "123456");

        //发起请求
        ResponseBean responseBean = httpTemplate.postByFrom(url, createHeader("testPostByFormAndObj"), paramMap, ResponseBean.class);
        System.out.println(responseBean.toString());
    }

    /**
     * 模拟JSON提交，post请求
     */
    @Test
    public void testPostByJson(){
        //请求地址
        String url = "http://localhost:8080/testPostByJson";

        //入参
        RequestBean request = new RequestBean();
        request.setUserName("唐三藏");
        request.setUserPwd("123456789");

        //发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        ResponseBean responseBean = httpTemplate.postByJson(url, createHeader("testPostByJson"), request, ResponseBean.class);
        System.out.println(responseBean.toString());
    }

    /**
     * 重定向，post请求，json方式提交
     */
    @Test
    public void testPostByLocation(){
        //请求地址
        String url = "http://localhost:8080/testPostByLocation";

        //入参
        RequestBean request = new RequestBean();
        request.setUserName("唐三藏");
        request.setUserPwd("123456789");

        //用于提交完成数据之后的页面跳转
        String uri = httpTemplate.postForLocation(url,  createHeader("testPostByLocation"), request);
        System.out.println(uri);
    }


    /**
     * put请求，json方式提交
     */
    @Test
    public void testPutByJson(){
        //请求地址
        String url = "http://localhost:8080/testPutByJson";

        //入参
        RequestBean request = new RequestBean();
        request.setUserName("唐三藏");
        request.setUserPwd("123456789000");

        //模拟JSON提交，put请求
        ResponseBean responseBean = httpTemplate.put(url,  createHeader("testPutByJson"), request, ResponseBean.class);
        System.out.println(responseBean.toString());
    }

    /**
     * delete请求，json方式提交
     */
    @Test
    public void testDeleteByJson(){
        //请求地址
        String url = "http://localhost:8080/testDeleteByJson";

        //模拟JSON提交，delete请求
        ResponseBean responseBean = httpTemplate.delete(url,  createHeader("testDeleteByJson"), ResponseBean.class);
        System.out.println(responseBean.toString());
    }

    /**
     * 文件上传，post请求
     */
    @Test
    public void uploadFile(){
        //需要上传的文件
        String filePath = "/Users/panzhi/Desktop/Jietu20220205-194655.jpg";

        //请求地址
        String url = "http://localhost:8080/upload";

        //提交参数设置
        MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
        param.add("uploadFile", new FileSystemResource(new File(filePath)));
        //服务端如果接受额外参数，可以传递
        param.add("userName", "张三");

        ResponseBean responseBean = httpTemplate.uploadFile(url, createHeader("uploadFile"), param, ResponseBean.class);
        System.out.println(responseBean.toString());
    }

    /**
     * 小文件下载
     * @throws IOException
     */
    @Test
    public void downloadFile() throws IOException {
        String userName = "张三";
        String fileName = "f9057640-90b2-4f86-9a4b-72ad0e253d0d.jpg";
        //请求地址
        String url = "http://localhost:8080/downloadFile/{1}/{2}";

        //发起请求,直接返回对象（restful风格）
        byte[] stream = httpTemplate.downloadFile(url, createHeader("downloadFile"), userName,fileName);

        // 将下载下来的文件内容保存到本地
        String targetPath = "/Users/panzhi/Desktop/"  + fileName;
        Files.write(Paths.get(targetPath), Objects.requireNonNull(stream, "未获取到下载文件"));
    }

    /**
     * 大文件下载
     * @throws IOException
     */
    @Test
    public void downloadBigFile() {
        String userName = "张三";
        String fileName = "f9057640-90b2-4f86-9a4b-72ad0e253d0d.jpg";
        String targetPath = "/Users/panzhi/Desktop/"  + fileName;

        //请求地址
        String url = "http://localhost:8080/downloadFile/{1}/{2}";

        //对响应进行流式处理而不是将其全部加载到内存中
        httpTemplate.downloadBigFile(url, createHeader("downloadBigFile"), clientHttpResponse -> {
            Files.copy(clientHttpResponse.getBody(), Paths.get(targetPath));
            return null;
        }, userName, fileName);
    }


    /**
     * 自定义请求头部
     * @param value
     * @return
     */
    private Map<String, String> createHeader(String value){
        Map<String, String> headers = new HashMap<>();
        headers.put("token", value);
        return headers;
    }
}
  • 假如返回的对象是一个范型，应该怎么处理呢？

在上篇文章中，我们介绍的返回对象都是非范型，例如返回的都是ResponseBean这个业务对象，用法也很简单，以POST请求+JSON提交方式为例，通过如下方式即可实现返回对象的序列化！

ResponseBean responseBean = httpTemplate.postByJson(url, createHeader("testPostByJson"), request, ResponseBean.class);

但是，假如返回的对象是ResponseBean<xxx>这样的，通过上面的方式来操作会直接报错！

当遇到返回的对象是范型类型的时候，我们可以这样操作！

以下面这个/testPostByJsonObj接口为例！

/**
 * 模拟JSON请求，post方法测试
 * @param request
 * @return
 */
@RequestMapping(value = "testPostByJsonObj", method = RequestMethod.POST)
public ResponseBeanObj<ResponseBean> testPostByJsonObj(@RequestBody RequestBean requestBean,
                                              HttpServletRequest request){
    HttpServletRequestLog.systemLog(request);
    //范型测试
    ResponseBean responseBean = new ResponseBean();
    responseBean.setCode("200000");
    responseBean.setMsg("responseBean");

    //范型测试
    ResponseBeanObj<ResponseBean> result = new ResponseBeanObj<>();
    result.setCode("200");
    result.setMsg("请求成功，方法：testPostByJsonObj，请求参数：" + JSON.toJSONString(requestBean));
    result.setObj(responseBean);
    System.out.println(JSON.toJSONString(result));
    return result;
}

使用RestTemplate工具发起网络请求，代码如下！

//将返回的范型对象包装到ParameterizedTypeReference对象里面
ParameterizedTypeReference<ResponseBeanObj<ResponseBean>> typeRef = new ParameterizedTypeReference<ResponseBeanObj<ResponseBean>>() {};

//使用restTemplate发起网络请求
ResponseBeanObj<ResponseBean> responseBean = restTemplate.exchange(url, HttpMethod.POST, request, typeRef);

采用restTemplate.exchange()方法，即可实现返回对象范型类型的反序列化！

如果使用上面封装的HttpTemplate工具进行操作，也更简单，代码如下：

/**
 * 模拟JSON提交，post请求，范型返回对象测试
 */
@Test
public void testPostByJsonObj(){
    //请求地址
    String url = "http://localhost:8080/testPostByJsonObj";

    //入参
    RequestBean request = new RequestBean();
    request.setUserName("唐三藏");
    request.setUserPwd("123456789");

    //发送post请求
    ParameterizedTypeReference<ResponseBeanObj<ResponseBean>> typeRef = new ParameterizedTypeReference<ResponseBeanObj<ResponseBean>>() {};
    //范型测试
    ResponseBeanObj<ResponseBean> responseBean = httpTemplate.postByJson(url, createHeader("testPostByJsonObj"), request, typeRef);
    System.out.println(JSON.toJSONString(responseBean));
}

三、自定义拦截器

在某些场景下，当你使用restTemplate发起网络请求时，所有的请求头部需要带上统一的参数，例如Authorization鉴权码，这个时候改怎么办呢？

可能有的同学，想到的就是在传参数的时候，带上请求头部参数！这种方法也可以解决问题！

有没有好的办法统一入口加入呢？

答案肯定是有的，我们可以利用RestTemplate提供的拦截器链来解决这个问题。

例如在RestTemplate初始化之后，添加一个拦截器，然后在拦截器的请求头部统一注入鉴权码，就可以轻松实现全局加入某个参数，方式如下！

/**
 * 初始化RestTemplate
 * @return
 */
@Bean
public RestTemplate restTemplate(){
    RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory());
    // 添加一个拦截器，在请求头部添加 Authorization 鉴权码
    restTemplate.getInterceptors().add((request, body, execution) -> {
        request.getHeaders().add("Authorization", "xxxxxXXXXX");
        return execution.execute(request, body);
    });
    return restTemplate;
}

四、小结

通过本章的讲解，想必读者初步的了解了如何基于RestTemplate做第二次封装，以便于更佳适配当前团队开发人员的习惯。

RestTemplate的功能其实非常强大，作者也仅仅学了点皮毛，在后续如果有新的功能，也会分享给大家，希望对网友们有所帮助！

相关推荐

墨尔本一华裔男子与亚裔男子分别失踪数日 警方寻人

中新网5月15日电据澳洲新快网报道，据澳大利亚维州警察局网站消息，22岁的华裔男子邓跃(Yue‘Peter’Deng，音译)失踪已6天，维州警方于当地时间13日发布寻人通告，寻求公众协助寻找邓跃。华...

网络交友须谨慎!美国犹他州一男子因涉嫌杀害女网友被捕

伊森·洪克斯克（图源网络，侵删）据美国广播公司（ABC）25日报道，美国犹他州一名男子于24日因涉嫌谋杀被捕。警方表示，这名男子主动告知警局，称其杀害了一名在网络交友软件上认识的25岁女子。雷顿警...

一课译词:来龙去脉（来龙去脉 的意思解释）

Mountainranges[Photo/SIPA]“来龙去脉”，汉语成语，本指山脉的走势和去向，现比喻一件事的前因后果（causeandeffectofanevent），可以翻译为“i...

高考重要考点:range（range高考用法）

range可以用作动词，也可以用作名词，含义特别多，在阅读理解中出现的频率很高，还经常作为完形填空的选项，而且在作文中使用是非常好的高级词汇。...

C++20 Ranges:现代范围操作（现代c++白皮书）

1.引言：C++20Ranges库简介C++20引入的Ranges库是C++标准库的重要更新，旨在提供更现代化、表达力更强的方式来处理数据序列（范围，range）。Ranges库基于...

学习VBA，报表做到飞 第二章 数组 2.4 Filter函数

第二章数组2.4Filter函数Filter函数功能与autofilter函数类似，它对一个一维数组进行筛选，返回一个从0开始的数组。...

VBA学习笔记:数组:数组相关函数—Split，Join

Split拆分字符串函数，语法Split（expression，字符，Limit，compare），第1参数为必写，后面3个参数都是可选项。Expression为需要拆分的数据，“字符”就是以哪个字...

VBA如何自定义序列，学会这些方法，让你工作更轻松

No.1在Excel中，自定义序列是一种快速填表机制，如何有效地利用这个方法，可以大大增加工作效率。通常在操作工作表的时候，可能会输入一些很有序的序列，如果一一录入就显得十分笨拙。Excel给出了一种...

Excel VBA入门教程1.3 数组基础（vba数组详解）

1.3数组使用数组和对象时，也要声明，这里说下数组的声明：'确定范围的数组，可以存储b-a+1个数，a、b为整数Dim数组名称(aTob)As数据类型Dimarr...

远程网络调试工具百宝箱-MobaXterm

MobaXterm是一个功能强大的远程网络工具百宝箱，它将所有重要的远程网络工具（SSH、Telnet、X11、RDP、VNC、FTP、MOSH、Serial等）和Unix命令（bash、ls、cat...

AREX:携程新一代自动化回归测试工具的设计与实现

一、背景随着携程机票BU业务规模的不断提高，业务系统日趋复杂，各种问题和挑战也随之而来。对于研发测试团队，面临着各种效能困境，包括业务复杂度高、数据构造工作量大、回归测试全量回归、沟通成本高、测试用例...

Windows、Android、IOS、Web自动化工具选择策略

Windows平台中应用UI自动化测试解决方案AutoIT是开源工具，该工具识别windows的标准控件效果不错，但是当它遇到应用中非标准控件定义的UI元素时往往就无能为力了，这个时候选择silkte...

python自动化工具:pywinauto（python快速上手 自动化）

简介Pywinauto是完全由Python构建的一个模块，可以用于自动化Windows上的GUI应用程序。同时，它支持鼠标、键盘操作，在元素控件树较复杂的界面，可以辅助我们完成自动化操作。我在...

时下最火的 Airtest 如何测试手机 APP?

引言Airtest是网易出品的一款基于图像识别的自动化测试工具，主要应用在手机APP和游戏的测试。一旦使用了这个工具进行APP的自动化，你就会发现自动化测试原来是如此简单！！连接手机要进行...

【推荐】7个最强Appium替代工具，移动App自动化测试必备!

在移动应用开发日益火爆的今天，自动化测试成为了确保应用质量和用户体验的关键环节。Appium作为一款广泛应用的移动应用自动化测试工具，为测试人员所熟知。然而，在不同的测试场景和需求下，还有许多其他优...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表