Forest 使用简介

最新推荐文章于 2024-05-15 21:30:00 发布
最新推荐文章于 2024-05-15 21:30:00 发布
阅读量1.5w 收藏 88
点赞数 10
分类专栏： 学习笔记 文章标签： RPC Forest
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41133233/article/details/113355741
版权

一. 背景：

最近小熙在写对接，涉及到一些远程调用，用的是httpclient实现的，但是觉得有些麻烦。有没有封装过的框架，让操作更方便呢，有的比如：Forset。

  1. 介绍：
    Forest 是一个开源的 Java HTTP 客户端框架，它能够将 HTTP 的所有请求信息（包括 URL、Header 以及 Body 等信息）绑定到您自定义的 Interface 方法上，能够通过调用本地接口方法的方式发送 HTTP 请求。

  2. 好处：
    使用 Forest 就像使用类似 Dubbo 那样的 RPC 框架一样，只需要定义接口，调用接口即可，不必关心具体发送 HTTP 请求的细节。同时将 HTTP 请求信息与业务代码解耦，方便您统一管理大量 HTTP 的 URL、Header 等信息。而请求的调用方完全不必在意 HTTP 的具体内容，即使该 HTTP 请求信息发生变更，大多数情况也不需要修改调用发送请求的代码。

  3. 原理：
    Forest 会将您定义好的接口通过动态代理的方式生成一个具体的实现类，然后组织、验证 HTTP 请求信息，绑定动态数据，转换数据形式，SSL 验证签名，调用后端 HTTP API(httpclient 等 API)执行实际请求，等待响应，失败重试，转换响应数据到 Java 类型等脏活累活都由这动态代理的实现类给包了。 请求发送方调用这个接口时，实际上就是在调用这个干脏活累活的实现类。

  4. 架构：
    forest架构图

二： 依赖引入和配置yml：

这里小熙使用的项目是 springboot 的，所以是基于此演示的
坐标版本引用的是 1.5.0-RC2 的，所以以下演示都是基于此版本的

  1. 引入坐标：

    <dependency>
    <groupId>com.dtflys.forest</groupId>
    <artifactId>spring-boot-starter-forest</artifactId>
    <version>1.5.0-RC2</version>
</dependency>

    辅助 json 解析工具坐标（Fastjson依赖：版本 >= 1.2.48）：

       <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.48</version>
  </dependency>

  2. yml中的配置：

       forest:
     bean-id: forestConfiguration # 在spring上下文中bean的id, 默认值为forestConfiguration
     backend: okhttp3             # 后端HTTP API： 默认使用：okhttp3，也可以替换成：httpclient
     max-connections: 1000        # 连接池最大连接数，默认值为500
     max-route-connections: 500   # 每个路由的最大连接数，默认值为500
     timeout: 3000                # 请求超时时间，单位为毫秒, 默认值为3000
     connect-timeout: 3000        # 连接超时时间，单位为毫秒, 默认值为2000
     retry-count: 1               # 请求失败后重试次数，默认为0次不重试
     ssl-protocol: SSLv3          # 单向验证的HTTPS的默认SSL协议，默认为SSLv3
     logEnabled: true             # 打开或关闭日志，默认为true，也可以在单个方法上加注解是否开启：@LogEnabled

    获取Forest在spring上下文中的bean

    @Resource(name = "forestConfiguration")
private ForestConfiguration forestConfiguration;

三. 使用介绍：

1. 请求类型：可支持（GET, POST, PUT, HEAD, OPTIONS, DELETE）

	    /**
	     * 测试访问百度
	     * 这里使用的是Get请求，你也可以简写为：@Get
	     * 
	     * 下面的请求同理
	     * 
	     * @return
	     */
	    @GetRequest(url = "http://www.baidu.com")
	    String accessBaiDu();
        
        /**
         * 也可以在请求里面指定类型
         * 
         * 下面的请求同理
         * 
         * @return
	     */
        @Request(url = "http://www.baidu.com", type = "get")
        String accessBaiDuRequestType();
        
        @Post(url = "http://www.baidu.com")
        String accessBaiDuPost();
    
        @Put(url = "http://www.baidu.com")
        String accessBaiDuPut();
    
        @DeleteRequest(url = "http://www.baidu.com")
        String accessBaiDuDelete();

2. 动态替换请求中变量（可传入）：

	    /**
	     * post请求
	     * @param domainName 参数传递domainName（变量绑定是@DataVariable，视情况而定可以不出现在url上）
	     * @param port 参数传递 port（变量绑定是@DataVariable）
	     * @return
	     */
	    @PostRequest(url = "http://${domainName}:${port}")
	    String testDataVariable(@DataVariable("domainName") String domainName, @DataVariable("port") Integer port);

3. 动态替换请求变量的优化（对模板替换和批量参数等不够优雅和繁杂）

	    /**
	     * Query的时候需要注意的点：
	     * (1) 需要单个单个定义 参数名=参数值 的时候，@Query注解的value值一定要有，比如 @Query("name") String name
	     *
	     * (2) 需要绑定对象的时候，@Query注解的value值一定要空着，比如 @Query User user 或 @Query Map map
	     */
	   
	    /**
	     * post请求
	     * @param domainName (@Query修饰的参数一定会出现在url中)
	     * @param port
	     * @return
	     */
	    @PostRequest(url = "http://domainName:port")
	    String testQuery(@Query("domainName") String domainName, @Query("port") Integer port);

       /**
	     * post请求
	     * 使用 @Query 注解，可以修饰 Map 类型的参数
	     * 很自然的，Map 的 Key 将作为 URL 的参数名， Value 将作为 URL 的参数值
	     * 这时候 @Query 注解不定义名称
	     * @param map
	     * @return
	     */
	    @PostRequest(url = "http://domainName:port")
	    String testQuery(@Query Map<String, Object> map);

	    /**
	     * @Query 注解也可以修饰自定义类型的对象参数
	     * 依据对象类的 Getter 和 Setter 的规则取出属性
	     * 其属性名为 URL 参数名，属性值为 URL 参数值
	     * 这时候 @Query 注解不定义名称
	     * @param urlClass 这是你的入参对象
	     * @return
	     */
	    @PostRequest(url = "http://domainName:port")
	    String testQuery(@Query UrlClass urlClass);

4. 关于请求头的设置（以下例子中依次递增的是优化方案）：

		    /*
		     *  @Header使用注意事项
		     * (1) 需要单个单个定义请求头的时候，@Header注解的value值一定要有，比如 @Header("Content-Type") String contentType
		     *
		     * (2) 需要绑定对象的时候，@Header注解的value值一定要空着，比如 @Header MyHeaders headers 或 @Header Map headerMap
		     */
		   
		    /**
		     * 默认get请求，在head中也可以使用@Query设置值同理@DataVariable
		     * @param encoding
		     * @return
		     */
		    @Request(
		            url = "http://www.baidu.com",
		            headers = {
		                    "Accept-Charset: ${encoding}",
		                    "Content-Type: text/plain"
		            }
		    )
		    String testheaders(@Query("encoding") String encoding);
	
		    /**
		     * post请求
		     * 使用 @Header 注解将参数绑定到请求头上
		     * @Header 注解的 value 指为请求头的名称，参数值为请求头的值
		     * @Header("Accept") String accept将字符串类型参数绑定到请求头 Accept 上
		     * @Header("accessToken") String accessToken将字符串类型参数绑定到请求头 accessToken 上
		     * @param accept
		     * @param accessToken
		     */
		    @Post("http://www.baidu.com")
		    void testHead(@Header("Accept") String accept, @Header("accessToken") String accessToken);
		
		    /**
		     * 使用 @Header 注解可以修饰 Map 类型的参数
		     * Map 的 Key 指为请求头的名称，Value 为请求头的值
		     * 通过此方式，可以将 Map 中所有的键值对批量地绑定到请求头中
		     * @param headerMap
		     */
		    @Post("http://www.baidu.com")
		    void testHead(@Header Map<String, Object> headerMap);
		
		
		    /**
		     * 使用 @Header 注解可以修饰自定义类型的对象参数
		     * 依据对象类的 Getter 和 Setter 的规则取出属性
		     * 其属性名为 URL 请求头的名称，属性值为请求头的值
		     * 以此方式，将一个对象中的所有属性批量地绑定到请求头中
		     */
		    @Post("http://localhost:8080/hello/user?username=foo")
		    void testHead(@Header HeaderInfo headersInfo);

5. 请求中的附加参数（head和body中）：

	    /**
	     * delete请求
	     * @param url
	     * @param param 这是数据参数，附加在请求上，get在head，post在body
	     *              此方法@DataParam已过时
	     * @return
	     */
	    @DeleteRequest(url = "${url}")
	    String testVariableAndParam(@DataVariable("url") String url, @DataParam("param") String param);

        /**
	     * @Body注解修饰的参数一定会绑定到请求体中
	     * 默认body格式为 application/x-www-form-urlencoded，即以表单形式序列化数据
	     * @param username
	     * @param password
	     * @return
	     *    username=xxx&password=xxx （这是默认格式，如果要转为json格式，在请求头中设置即可Content-Type: application/json）
	     */
	    @Post(
	            url = "http://www.baidu.com",
	            headers = {"Accept:text/plain"}
	    )
	    String testBody(@Body("username") String username,  @Body("password") String password);
	
	    /**
	     * 也可以使用@Body修饰，将整个类以表单方式传输
	     * @param item
	     * @return
	     */
	    @Post(
	            url = "http://www.baidu.com",
	            headers = {"Accept:text/plain"}
	    )
	    String testBody(@Body Item item);
	
	    /**
	     * 被 @JSONBody注解修饰的参数会根据其类型被自定解析为JSON字符串, (也可以拆分开，修饰单个参数，如 @JSONBody(string) String string)
	     *  修饰map等亦可以，当修饰 list的时候，结果类型可为["A", "B", "C"]
	     * 使用 @JSONBody注解时可以省略 contentType = "application/json"属性设置
	     * @param item
	     * @return
	     *    {"username": "xx", "password": "xxx"}
	     */
	    @Post("http://www.baidu.com")
	    String testJSONBody(@JSONBody Item item);

6. 基础请求（提取封装请求相关属性，避免重复编写）：

	   /**
	     * @BaseRequest 为配置接口层级请求信息的注解，
	     * 其属性会成为该接口下所有请求的默认属性，
	     * 但可以被方法上定义的属性所覆盖
	     *
	     * @BaseRequest注解中的所有字符串属性都可以通过模板表达式引用全局变量或方法中的参数。
	     * 若全局变量中已定义 baseUrl
	     * 便会将全局变量中的值绑定到 @BaseRequest 的属性中
	     */
	    @BaseRequest(
	            baseURL = "${baseUrl}",     // 默认域名
	            headers = {
	                    "Accept:text/plain"                // 默认请求头
	            },
	            sslProtocol = "sslType"                    // 默认单向SSL协议(TLS)
	    )
	    interface MyClient {
	
	        /**
	         * 在 @BaseRequest 中的属性亦可以引用方法中的绑定变量名的参数
	         * @param baseUrl 在BaseRequest注解中被引用
	         * @return
	         */
	        @Get("/hello/user")
	        String testOne(@DataVariable("baseUrl") String baseUrl);
	
	        /**
	         * 方法的URL不必再写域名部分
	         * @param sslType 在BaseRequest注解中被引用
	         * @return
	         */
	        @Get("/hello/user")
	        String testTwo(@Query("sslType") String sslType);
	
	        /**
	         * 若方法的URL是完整包含http://开头的，那么会以方法的URL中域名为准，不会被接口层级中的baseUrl属性覆盖
	         * @param username
	         * @return
	         */
	        @Get("http://www.xxx.com/hello/user")
	        String testThree(@Query("username") String username);
	
	        /**
	         * 覆盖请求头中信息
	         * @param username
	         * @return
	         */
	        @Get(
	                url = "/hello/user",
	                headers = {
	                        "Accept:application/json"      // 覆盖接口层级配置的请求头信息
	                }
	        )
	        String testFour(@Query("username") String username);
	
	    }

7. 接收响应封装数据：

	   /**
	     * dataType属性指定了该请求响应返回的数据类型，目前可选的数据类型有三种: text, json, xml
	     * Forest请求会自动将响应的返回数据反序列化成您要的数据类型。想要接受指定类型的数据需要完成两步操作：
	     * 第一步：定义dataType属性
	     * 第二步：指定反序列化的目标类型
	     * 从1.4.0版本开始，dataType 属性默认为 auto（自动判断数据类型）， 也就是说 dataType 属性可以完全省略不填，Forest会自行判断返回的数据类型是哪种格式。
	     */
	
	    /**
	     * dataType为text或不填时，请求响应的数据将以文本字符串的形式返回回来
	     * @return
	     */
	    @Request(
	            url = "http://localhost:8080/text/data",
	            dataType = "text"
	    )
	    String testQueryStringData();
	
	    /**
	     * dataType属性指明了返回的数据类型为JSON
	     * 从1.4.0版本开始，dataType 属性默认为 auto（自动判断数据类型），
	     * 也就是说 dataType 属性可以完全省略不填，Forest会自行判断返回的数据类型是哪种格式。
	     * @param id
	     * @return
	     */
	    @Get(
	            url = "http://localhost:8080/user?id=${0}",
	            dataType = "json"   // 注意这里从1.4开始可以不写，自动判断
	    )
	    User testQueryUserData(Integer id);
	
	
	    /**
	     * ForestResponse 可以获取响应内容，也可以得到响应头等信息
	     * ForestResponse 可以作为请求方法的返回类型
	     * ForestResponse 为带泛型的类，其泛型参数中填的类作为其响应反序列化的目标类型
	     * @param item
	     * @return
	     */
	    @Post("http://localhost:8080/user")
	    ForestResponse<String> testResponseString(@JSONBody Item item);
	
	    /**
	     * 响应封装在对象中
	     *  日志打印默认为true
	     * @param item
	     * @return
	     */
	    @LogEnabled(value = true)
	    @Post("http://localhost:8080/user")
	    ForestResponse<Item> testResponseItem(@JSONBody Item item);

其中用ForestResponse对象接到请求响应数据后便可以获取响应内容：

	// 以 ForestResponse类型变量接受响应数据
	ForestResponse<String> response = client.postUser(user);
	
	// 用 isError方法去判断请求是否失败
	if (response.isError()) {
	    ... ...
	}
	
	// 用isSuccess方法去判断请求是否成功
	if (response.isSuccess()) {
	    ... ...
	}
	
	// 以字符串方式读取请求响应内容
	String text = response.readAsString();
	
	// getContent方法可以获取请求响应内容文本
	// 和 readAsString方法不同的地方在于，getContent方法不会读取二进制形式数据内容，
	// 而 readAsString方法会将二进制数据转换成字符串读取
	String content = response.getContent();
	
	// 获取反序列化成对象类型的请求响应内容
	// 因为返回类型为 ForetReponse<String>, 其泛型参数为String
	// 所以这里也用 String类型获取结果        
	String result = response.getResult();
	
	// 以字节数组的形式获取请求响应内容
	byte[] byteArray = response.getByteArray();
	
	// 以输入流的形式获取请求响应内容
	InputStream in = response.getInputStream();

    // 根据响应头名称获取单个请求响应头
	ForestHeader header = response.getHeader("Content-Type");
	// 响应头名称
	String headerName = header.getName();
	// 响应头值
	String headerValue = header.getValue();
	
	// 根据响应头名称获取请求响应头列表
	List<ForestHeader> heaers = response.getHeaders("Content-Type");
	
	// 根据响应头名称获取请求响应头值
	String val = response.getHeaderValue("Content-Type");
	
	// 根据响应头名称获取请求响应头值列表
	List<String> vals = response.getHeaderValues("Content-Type");

8. 回调函数（可用于成功和失败默认回调）：

	   /**
	     * 在异步请求中只能通过OnSuccess<T>回调函数接或Future<T>返回值接受数据。
	     * 而在同步请求中，OnSuccess<T>回调函数和任何类型的返回值都能接受到请求响应的数据。
	     * OnError回调函数可以用于异常处理，一般在同步请求中使用try-catch也能达到同样的效果。
	     */
	    
	    /**
	     * 请求使用成功和失败回调
	     *
	     * 如这两个回调函数的类名所示的含义一样，OnSuccess<T>在请求成功调用响应时会被调用，而OnError在失败或出现错误的时候被调用。
	     * 其中OnSuccess<T>的泛型参数T定义为请求响应返回结果的数据类型。
	     * @param username
	     * @param onSuccess
	     * @param onError
	     * @return
	     */
	    @Request(
	            url = "http://localhost:8080/hello/user",
	            headers = {"Accept:text/plain"},
	            data = "username=${username}"
	    )
	    String sendAndCallback(@DataVariable("username") String username, OnSuccess<String> onSuccess, OnError onError);

回调使用演示：

	testInterface.sendAndCallback("小熙", (String resultString, ForestRequest request, ForestResponse response) -> {
	                    // 成功响应回调（如果是异步，这里可以操作响应数据封装）
	                    System.out.println(resultString);
	                },
	                (ForestRuntimeException ex, ForestRequest request, ForestResponse response) -> {
	                    // 异常回调
	                    System.out.println(ex.getMessage());
	                });

9. 异步请求：

	    /**
	     * 在Forest使用异步请求，可以通过设置@Request注解的async属性为true实现，不设置或设置为false即为同步请求。
	     */
	
	    /**
	     * 异步请求，成功回调(在异步请求中只能通过OnSuccess<T>回调函数接或Future<T>返回值接受数据，所以返回值为void)
	     * @param username
	     * @param onSuccess
	     */
	    @Request(
	            url = "http://localhost:8080/hello/queryUserByName/username",
	            async = true,
	            headers = {"Accept:text/plain"}
	    )
	    void testAsyncGet(@Query("username") String username, OnSuccess<String> onSuccess);
	
	    /**
	     * 异步请求，Future封装接收
	     * @param username
	     * @return
	     */
	    @Request(
	            url = "http://localhost:8080/hello/queryUserByName/username",
	            async = true,
	            headers = {"Accept:text/plain"}
	    )
	    Future<String> testAsyncGet(@Query("username") String username);

调用演示：

	        // 回调异步
	        testInterface.testAsyncGet("小熙", (String resultString, ForestRequest request, ForestResponse response) -> {
	            // 打印成功请求返回的结果
	            System.out.println(resultString);
	        });
	        
	        // future异步
	        Future<String> stringFuture = testInterface.testAsyncGet("小熙");
	        // 获取future异步成功调用的返回结果
	        String string = stringFuture.get();

10. 文件上传：

	    /**
	     * 上传下载
	     * Forest从 1.4.0 版本开始支持多种形式的文件上传和文件下载功能
	     */
	
	    /**
	     * 用@DataFile注解修饰要上传的参数对象
	     * OnProgress 参数为监听上传进度的回调函数
	     * @param filePath
	     * @param onProgress
	     * @return
	     */
	    @Post(url = "/upload")
	    Map testUpload(@DataFile("file") String filePath, OnProgress onProgress);
	
	    /**
	     * File类型对象
	     */
	    @Post(url = "/upload")
	    Map testUpload(@DataFile("file") File file, OnProgress onProgress);
	
	    /**
	     * byte数组
	     * 使用byte数组和Inputstream对象时一定要定义fileName属性
	     */
	    @Post(url = "/upload")
	    Map testUpload(@DataFile(value = "file", fileName = "${1}") byte[] bytes, String filename);
	
	    /**
	     * Inputstream 对象
	     * 使用byte数组和Inputstream对象时一定要定义fileName属性
	     */
	    @Post(url = "/upload")
	    Map testUpload(@DataFile(value = "file", fileName = "${1}") InputStream in, String filename);
	
	    /**
	     * Spring Web MVC 中的 MultipartFile 对象
	     */
	    @PostRequest(url = "/upload")
	    Map testUpload(@DataFile(value = "file") MultipartFile multipartFile, OnProgress onProgress);
	
	    /**
	     * Spring 的 Resource 对象
	     */
	    @Post(url = "/upload")
	    Map testUpload(@DataFile(value = "file") Resource resource);

调用演示：

	Map result = testInterface.testUpload("D:\\TestUpload\\xxx.jpg", progress -> {
	            System.out.println("total bytes: " + progress.getTotalBytes());   // 文件大小
	            System.out.println("current bytes: " + progress.getCurrentBytes());   // 已上传字节数
	            System.out.println("progress: " + Math.round(progress.getRate() * 100) + "%");  // 已上传百分比
	            if (progress.isDone()) {   // 是否上传完成
	                System.out.println("--------   Upload Completed!   --------");
	            }
	        });

批量上传：

	   /**
	     * 批量上传
	     */
	
	    /**
	     * 上传Map包装的文件列表
	     * 其中 ${_key} 代表Map中每一次迭代中的键值
	     * @param byteArrayMap
	     * @return
	     */
	    @PostRequest(url = "/upload")
	    ForestRequest<Map> uploadByteArrayMap(@DataFile(value = "file", fileName = "${_key}") Map<String, byte[]> byteArrayMap);
	
	    /**
	     * 上传List包装的文件列表
	     * 其中 ${_index} 代表每次迭代List的循环计数（从零开始计）
	     * @param byteArrayList
	     * @return
	     */
	    @PostRequest(url = "/upload")
	    ForestRequest<Map> uploadByteArrayList(@DataFile(value = "file", fileName = "test-img-${_index}.jpg") List<byte[]> byteArrayList);
	
	    /**
	     * 上传数组包装的文件列表
	     * 其中 ${_index} 代表每次迭代List的循环计数（从零开始计）
	     * @param byteArrayArray
	     * @return
	     */
	    @PostRequest(url = "/upload")
	    ForestRequest<Map> uploadByteArrayArray(@DataFile(value = "file", fileName = "test-img-${_index}.jpg") byte[][] byteArrayArray);

11. 文件下载：

		    /**
		     * 在方法上加上@DownloadFile注解
		     * dir属性表示文件下载到哪个目录
		     * filename属性表示文件下载成功后以什么名字保存，如果不填，这默认从URL中取得文件名
		     * OnProgress参数为监听上传进度的回调函数
		     * @param dir
		     * @param filename
		     * @param onProgress
		     * @return
		     */
		    @Get(url = "http://localhost:8080/images/xxx.jpg")
		    @DownloadFile(dir = "${0}", filename = "${1}")
		    File testDownloadFile(String dir, String filename, OnProgress onProgress);
		
		    /**
		     * 如果您不想将文件下载到硬盘上，而是直接在内存中读取，可以去掉@DownloadFile注解，并且用以下几种方式定义接口:
		     */
		
		    /**
		     * 返回类型用byte[]，可将下载的文件转换成字节数组
		     * @return
		     */
		    @GetRequest(url = "http://localhost:8080/images/test-img.jpg")
		    byte[] downloadImageToByteArray();
		
		    /**
		     * 返回类型用InputStream，用流的方式读取文件内容
		     * @return
		     */
		    @GetRequest(url = "http://localhost:8080/images/test-img.jpg")
		    InputStream downloadImageToInputStream();

调用演示：

		File file = testInterface.testDownloadFile("D:\\TestDownload", "", progress -> {
		            System.out.println("total bytes: " + progress.getTotalBytes());   // 文件大小
		            System.out.println("current bytes: " + progress.getCurrentBytes());   // 已下载字节数
		            System.out.println("progress: " + Math.round(progress.getRate() * 100) + "%");  // 已下载百分比
		            if (progress.isDone()) {   // 是否下载完成
		                System.out.println("--------   Download Completed!   --------");
		            }
		        });

四： HTTPS请求：

为保证网络访问安全，现在大多数企业都会选择使用SSL验证来提高网站的安全性。

1. 单向认证：

全局配置可以配置一个全局统一的SSL协议，但现实情况是有很多不同服务（尤其是第三方）的API会使用不同的SSL协议，这种情况需要针对不同的接口设置不同的SSL协议。

    /**
     * 在某个请求接口上通过 sslProtocol 属性设置单向SSL协议
     * @return
     */
    @Get(
            url = "https://localhost:5555/hello/user",
            sslProtocol = "SSL"
    )
    ForestResponse<String> testTruestSSLGet();

    /**
     * 在一个个方法上设置太麻烦，也可以在 @BaseRequest 注解中设置一整个接口类的SSL协议
     */
    @BaseRequest(sslProtocol = "TLS")
    public interface SSLClient {

        /**
         * 类中使用
         * @return
         */
        @Get("https://localhost:5555/hello/user")
        String testTruestSSLGet();

    }

2. 双向认证

在yml中添加证书等配置：

		forest:
		  ...
		  ssl-key-stores:
			- id: keystore1                      # id为该keystore的名称，必填。你可以配置多个key，调用不同key即可
			     file: test.keystore             # 公钥文件地址
			     keystore-pass: 123456           # keystore秘钥
			     cert-pass: 123456               # cert秘钥
			     protocols: SSLv3                # SSL协议  
		    - id: keystore2                      # 第二个keystore
		      file: test2.keystore    
		      keystore-pass: abcdef  
		      cert-pass: abcdef      
		      protocols: SSLv3       
		      ...

接下来在代码中直接引用这个 id 对应的key：

    @Request(
            url = "https://localhost:5555/hello/user",
            keyStore = "keystore1"
    )
    String testTruestkeystoreGet();

五. 后语：

Forest 作为远程之间调用的封装，还有很多功能，这里小熙只是列出了大部分基础的功能，感兴趣的可以去官网看看哟。

程熙cjp
关注
  • 10
    点赞
  • 踩
  • 88
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
基于Springboot的Forest调用第三方API Demo
04-17
在本文中，我们将深入探讨如何使用Spring Boot框架结合Forest、Okhttp和HttpClient这三种不同的库来调用第三方API，特别是以高德地图API为例。首先，让我们了解Spring Boot的基础知识，然后逐一分析这三个库以及它们...
Ant-Forest:基于AutoJS的蚂蚁森林收能量脚本
05-13
简介 由 fork 而来，但是经过了各种改动，和原版功能差异较大 现在已经单独复制不再作为fork分支开发。基于 Autojs 的蚂蚁森林自动收能量脚本，采用 4.1.1 Alpha2 版本开发。解锁模块参考自：脚本执行依赖于： or 若...
Forest-极简的轻量级HTTP调用API框架
bbk_7887的专栏
01-05 2844
http://forest.dtflyx.com/
轻量级HTTP客户端框架—Forest学习笔记
Mr.X
04-17 9388
轻量级HTTP客户端框架—Forest学习笔记
解决forest低版本请求不安全的网站出现SSL认证不通过问题
最新发布
ZL_1618的博客
05-15 890
先说结论：无法解决那既然无法解决，为啥还要写这样一篇文章呢，是因为这个问题我弄了一天多，我觉得有必要记录一下；同时后面也是使用了hutool 的http作为代替方案，也是因为在hutool的官网没有特意标明，所以这也是一个理由吧！
一款直击痛点的http框架，让我超高效完成第三方接口对接
AlbenXie的博客
09-11 478
因为业务关系，要和许多不同第三方公司进行对接。这些服务商都提供基于http的api。但是每家公司提供api具体细节差别很大。有的基于RESTFUL规范，有的基于传统的http规范；有的需要在header里放置签名，有的需要SSL的双向认证，有的只需要SSL的单向认证；有的以JSON方式进行序列化，有的以XML方式进行序列化。类似于这样细节的差别太多了。 不同的公司API规范不一样，这很正常。但是对于我来说，我如果想要代码变得优雅。我就必须解决一个痛点： 不同服务商API那么多的差异点，如何才能维护一套.
Forest：跨服务调用，Http请求工具的简单使用
weixin_51028997的博客
08-23 534
Forest：一款基于httpClient的跨服务调用工具，简单易用，支持文件等复杂请求，以及所有请求方式。
接口中不需要登录的接口@base_request
weixin_30315723的博客
08-01 729
def base_request(sub_post): def inner(self, request): if request.method == 'POST': if request.content_type == 'application/json': body = request.body.decode('u...
一招搞定外部请求，这款 HTTP 客户端框架真的很强大！
Java知音
07-08 1142
一、Forest1.1 业务需求一般情况下是后端提供接口，前端调用，解决需求，但是有的时候为了方便，复用别人的接口（网上的，公共的第三方接口（短信、天气等）），就出现了后端调用后端接口的情况。此外，因为业务关系，要和许多不同第三方公司进行对接。这些服务商都提供基于http的api，但是每家公司提供api具体细节差别很大。有的基于RESTFUL规范，有的基于传统的http规范；有的需要在header...
Open-Forest-Training-2021
04-17
2021年开放森林培训教程的注意事项R的负责任机器学习简介短链接指向此页面的短链接： : 材料 数据请注意，这些是为模拟实际数据中存在的关系而生成的人工数据集。 其他工作坊2020年的eRum： ： BioColl 2021： ：
Python-Forest是一种编译为WebAssembly的函数式编程语言
08-10
Forest的核心语法设计简洁，鼓励使用高阶函数和不可变数据结构。编译器负责将Forest代码转化为WASM，这一过程涉及到语义分析、中间代码生成和目标代码优化等多个阶段。编译器的优化对于确保WASM代码的高效执行至关...
NUS-DataScience:使用R进行数据分析简介
04-29
在本课程"国大数据科学——使用R进行数据分析简介"中，我们将深入探讨R语言在数据科学领域的应用。R是一种广泛使用的统计分析和图形绘制的编程语言，尤其在数据挖掘、机器学习以及数据可视化方面有着强大的功能。...
ida：使用R进行数据分析简介（2013）
02-05
本文将通过“ida：使用R进行数据分析简介（2013）”这一主题，探讨R语言在数据分析领域的应用及其基本操作。 R语言的强大之处在于其庞大的生态系统，包括众多的包和库，这些包和库为各种复杂的数据处理任务提供了...
开源项目-forestgiant-stela.zip
10-25
1. **Stela项目简介** Stela是由Forest Giant开发的一款开源软件，其主要目标是解决在企业内部（on-premises）环境中，服务之间的动态发现和管理问题。通过使用GO语言，Stela实现了轻量级、高性能和跨平台的特点，...
08-python-oop简介-使用 OOP 对森林火灾建模-对象
02-12
首先，我们从"08.01-python-oop简介.ipynb"开始。在这一部分，你会了解到OOP的基本原理，包括类（Class）和对象（Instance）的概念。类是创建对象的蓝图，它定义了一组属性（Attributes）和方法（Methods）。对象则...
walk-in-the-forest:森林漫步的支持资源
05-12
走进森林 该存储库托管的相关资源。 Python笔记本 所有Python笔记本均位于code/notebooks...Matplotlib简介 Michaelis-Menten动力学概论 Lineweaver-Burk转换简介 酶抑制的类型 SIR模型简介 自然选择的基本模型
接口自动化之BaseRequest封装get/post方法
软件自动化测试技术交流、资源分享
06-12 151
可以将通用的get、post方法封装在一个公共的类中，后面需要用到在进行调用即可。
Forest-声明式HTTP客户端框架-集成到SpringBoot实现调用第三方restful api并实现接口数据转换
BADAO_LIUMANG_QIZHI的博客
04-19 4043
声明式HTTP客户端API框架，让Java发送HTTP/HTTPS请求不再难。它比OkHttp和HttpClient更高层，是封装调用第三方restful api client接口的好帮手，是retrofit和feign之外另一个选择。通过在接口上声明注解的方式配置HTTP请求接口。Forest的功能较多，下面记录一个比较常用的功能，就是调用第三方api获取数据，并将json数据解析成对象。
Forest详细介绍
qq_65377318的博客
09-03 5731
Forest 是一个开源的 Java HTTP 客户端框架，它能够将 HTTP 的所有请求信息（包括 URL、Header 以及 Body 等信息）绑定到您自定义的 Interface 方法上，能够通过调用本地接口方法的方式发送 HTTP 请求
r语言randomforest包具体使用方法
05-25
随机森林（Random Forest）是一种机器学习算法，它可以用于分类和回归问题。在R语言中，可以使用randomForest包来实现随机森林算法。下面是一些基本的使用方法： 1. 安装和加载randomForest包： ```R install.packages("randomForest") # 安装包 library(randomForest) # 加载包 ``` 2. 准备数据集，将数据集分成训练集和测试集： ```R data(iris) # 导入iris数据集 trainIndex <- sample(1:nrow(iris), 0.7*nrow(iris)) # 随机选取70%的数据作为训练集 trainData <- iris[trainIndex, ] # 训练集 testData <- iris[-trainIndex, ] # 测试集 ``` 3. 构建随机森林模型： ```R rfModel <- randomForest(Species ~ ., data = trainData, ntree = 500, importance = TRUE) ``` 其中，Species是目标变量，trainData是训练数据集，ntree是指定随机森林中树的数量，importance参数用于计算变量重要性。 4. 预测新数据： ```R pred <- predict(rfModel, testData) ``` 其中，rfModel是已经训练好的随机森林模型，testData是测试数据集。 5. 评估模型性能： 可以使用混淆矩阵、准确率、召回率等指标来评估模型性能。 ```R table(pred, testData$Species) # 混淆矩阵 ``` 可以使用caret包中的函数来计算准确率、召回率等指标。 ```R library(caret) confusionMatrix(data = pred, reference = testData$Species) # 计算混淆矩阵等指标 ``` 以上是randomForest包的基本使用方法，随机森林还有一些高级功能，比如out-of-bag误差估计、变量重要性等，可以参考包的官方文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值