http-invoker

最新推荐文章于 2022-10-24 15:52:17 发布
最新推荐文章于 2022-10-24 15:52:17 发布
阅读量203 收藏
点赞数
文章标签： json java
原文链接：https://my.oschina.net/chenxiaojie/blog/1542258
版权

花了一点时间，包装了下httpclient，填了常见的坑。

有兴趣的戳下方链接~~

https://github.com/chenxiaojie/http-invoker

基于apache httpclient的轻量http请求

特性

  1. 封装了httpclient, 仅暴露常用的配置, 将常见的坑填上
  2. 接口设计参考jsoup http, 十分便捷的请求让人耳目一新
  3. 支持所有的请求方式, GET,POST,PUT,DELETE,PATCH,HEAD,OPTIONS,TRACE
  4. 可以像rpc请求一样发http请求, 代码更加规范稳定, 易于管理
  5. 出参入参对json极为友好, 自动解析返回对象to pojo
  6. 当返回值为HttpResult时, 调用失败也不会抛出异常. GET请求不建议使用HttpResult, 非GET如POST/PUT/DELETE请求都建议使用HttpResult
  7. 支持返回值取jsonPath, 例如:msg.user.id/msg.user[1].id 参考测试包下com.chenxiaojie.http.invoker.test.http.test.ResultJsonPathTest
  8. 支持设计重试次数, 建议get请求都有重试机制, 参考测试包下com.chenxiaojie.http.invoker.test.http.test.RetryTest
  9. 支持上传各种类型的文件, 支持File/InputStream/byte[]/base64上传, 参考测试包下com.chenxiaojie.http.invoker.test.http.test.UploadFileTest
  10. 支持@PathVariable 如 http://.com/{key}/info -> http://.com/xiaojie.chen/info, 参考测试包下com.chenxiaojie.http.invoker.test.http.test.SimpleTest
  11. 支持请求拦截器和自定义httpclient, 参考com.chenxiaojie.http.invoker.test.http.test.CustomHttpClientTest

添加依赖

<dependency>
    <groupId>com.chenxiaojie</groupId>
    <artifactId>http-invoker</artifactId>
    <version>1.0.1</version>
</dependency>

如果您的项目中有依赖以下包,请指定以下版本或高于以下版本

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.1</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpcore</artifactId>
    <version>4.4.3</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpmime</artifactId>
    <version>4.5.1</version>
</dependency>
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.9</version>
</dependency>

快速入门

http-invoker-demo-web module是专门用于测试, 运行以下代码时, 请先启动这个web项目

使用HttpInvoker, 参考测试包下com.chenxiaojie.http.invoker.test.httpinvoker.HttpInvokerTest

public class HttpInvokerTest {

    @Test
    public void testGet() {
        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/1")
                .data("employeeId", "00160041")
                .data(ImmutableMap.of("employeeName", "陈孝杰1"))
                .data("ad", "xiaojie.chen", "ad", "xiaojie.chen1")
                .method(HttpMethod.GET)
                .execute();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testGet2() {
        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/2")
                .data("employeeId", "00160042")
                .data(ImmutableMap.of("employeeName", "陈孝杰2"))
                .data("ad", "xiaojie.chen", "ad", "xiaojie.chen2")
                .get();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Rule
    public ExpectedException thrown = ExpectedException.none();

    @Test
    public void testGet3() {
        thrown.expect(HttpRequestException.class);

        HttpInvoker.Response response = HttpInvoker.builder(HttpClientBuilder.builder().followRedirects(true).build())
                .uri(Consts.URL + "/redirect/loop")
                .get();

        response.log();
    }

    @Test
    public void testPost() {
        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/3")
                .data("employeeId", "00160043")
                .data(ImmutableMap.of("employeeName", "陈孝杰3"))
                .data("ad", "xiaojie.chen", "ad", "xiaojie.chen3")
                .post();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testPost2() {
        UserLoginModel userLoginModel = new UserLoginModel();
        userLoginModel.setLoginId(5);
        userLoginModel.setEmployeeId("0016004");
        userLoginModel.setEmployeeName("陈孝杰");
        userLoginModel.setAd("xiaojie.chen");

        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple?employeeName=employeeName陈孝杰")
                .data("ad", "xiaojie.chen", "ad", "xiaojie.chen3")
                .json(JSON.toJSONString(userLoginModel))
                .post();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testPost3() {
        InputStream in = Thread.currentThread().getClass().getResourceAsStream("/logo.png");
        InputStream in2 = Thread.currentThread().getClass().getResourceAsStream("/logo.png");
        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/file")
                .data("employeeId", "00160043")
                .data(ImmutableMap.of("employeeName", "陈孝杰3"))
                .data("ad", "xiaojie.chen", "ad", "xiaojie.chen3")
                .data("fileinput", "attachment.png", in)
                .data("fileinput2", "attachment2.png", in2)
                .post();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testPut() {

        UserLoginModel userLoginModel = new UserLoginModel();
        userLoginModel.setEmployeeId("0016004");
        userLoginModel.setEmployeeName("陈孝杰");
        userLoginModel.setAd("xiaojie.chen");

        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/1")
                .json(JSON.toJSONString(userLoginModel))
                .put();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testPatch() {

        UserLoginModel userLoginModel = new UserLoginModel();
        userLoginModel.setEmployeeId("0016004");
        userLoginModel.setEmployeeName("陈孝杰");
        userLoginModel.setAd("xiaojie.chen");

        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/2")
                .json(JSON.toJSONString(userLoginModel))
                .patch();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testDelete() {
        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/1")
                .data("aa", "陈孝杰")
                .delete();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testHead() {
        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/2")
                .head();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testOptions() {
        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/3")
                .options();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testTrace() {
        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/4")
                .trace();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testTrace2() {
        HttpRequestException httpRequestException = null;
        try {
            HttpInvoker.Response response = HttpInvoker.builder(HttpClientBuilder.builder().followRedirects(true).build())
                    .uri(Consts.URL + "/redirect/loop")
                    .trace();
            response.log();
        } catch (HttpRequestException e) {
            httpRequestException = e;
        }

        Assert.assertNull(httpRequestException);
    }

    @Test
    public void testHeaders() {
        HttpInvoker.Response response = HttpInvoker.builder(HttpClientBuilder.builder()
                .header("AAA", "VVV")
                .header(HttpHeaders.USER_AGENT, "VVVVVVFSDSFSF")
                .build())
                .uri(Consts.URL + "/simple/3")
                .data("employeeId", "00160041")
                .data(ImmutableMap.of("employeeName", "陈孝杰1"))
                .data("ad", "xiaojie.chen", "ad", "xiaojie.chen1")
                .header("AAA", "BBB")
                .header("AAA", "BBB2")
                .headers(ImmutableMap.of("BBB", "CCC"))
                .headers(ImmutableMap.of(HttpHeaders.USER_AGENT, "ASSSDDSDSDD"))
                .get();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testCookie() {
        BasicClientCookie cookie1 = new BasicClientCookie("Auth", "AuthAuth");
        cookie1.setPath("/");
        cookie1.setDomain("localhost");

        BasicClientCookie cookie2 = new BasicClientCookie("Auth2", "Auth2Auth2");
        cookie2.setPath("/");
        cookie2.setDomain("localhost");

        BasicClientCookie cookie3 = new BasicClientCookie("Auth3", "Auth3Auth3");
        cookie3.setPath("/");
        cookie3.setDomain("localhost");

        HttpInvoker.Response response = HttpInvoker.builder(HttpClientBuilder.builder()
                .header("AAA", "VVV")
                .header(HttpHeaders.USER_AGENT, "VVVVVVFSDSFSF")
                .cookie(cookie1)
                .cookies(Lists.<Cookie>newArrayList(cookie2, cookie3))
                .build())
                .uri(Consts.URL + "/simple/3")
                .data("employeeId", "00160041")
                .data(ImmutableMap.of("employeeName", "陈孝杰1"))
                .data("ad", "xiaojie.chen", "ad", "xiaojie.chen1")
                .header("AAA", "BBB")
                .header("AAA", "BBB2")
                .headers(ImmutableMap.of("BBB", "CCC"))
                .headers(ImmutableMap.of(HttpHeaders.USER_AGENT, "ASSSDDSDSDD"))
                .cookie("Auth", "123")
                .cookies(ImmutableMap.of("Auth5", "Auth5Auth5", "Auth6", "Auth6Auth6"))
                .get();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

    @Test
    public void testInterceptor() {

        HttpInvoker.Response response = HttpInvoker.builder()
                .uri(Consts.URL + "/simple/3")
                .data("employeeId", "00160041")
                .data(ImmutableMap.of("employeeName", "陈孝杰1"))
                .data("ad", "xiaojie.chen", "ad", "xiaojie.chen1")
                .header("AAA", "BBB")
                .header("AAA", "BBB2")
                .headers(ImmutableMap.of("BBB", "CCC"))
                .headers(ImmutableMap.of(HttpHeaders.USER_AGENT, "ASSSDDSDSDD"))
                .cookie("Auth", "123")
                .cookies(ImmutableMap.of("Auth5", "Auth5Auth5", "Auth6", "Auth6Auth6"))
                .interceptor(new HttpInvoker.Interceptor() {
                    @Override
                    public boolean intercept(HttpRequestBase httpRequestBase) throws HttpRequestException {
                        System.out.println(httpRequestBase);
                        return true;
                    }
                })
                .interceptor(new BasicAuthInterceptor("AAA", "BBB", "UTF-8"))
                .get();

        response.log();
        Assert.assertTrue(response.isSuccess());
    }

}

通过api的方式请求

java api

public interface SimpleHttpApi {

    @RequestMapping("/simple/{loginId}")
    Response<UserLoginModel> queryByLoginId(@PathVariable("loginId") int loginId);

    @RequestMapping("/simple/{loginId}")
    HttpResult<Response<UserLoginModel>> queryHttpResultByLoginId(@PathVariable("loginId") int loginId);

    @RequestMapping(value = "/simple/{loginId}", method = HttpMethod.GET)
    Response<UserLoginModel> getByLoginId(@PathVariable("loginId") int loginId,
                                          @RequestParam(value = "employeeId") String employeeId,
                                          @RequestParam(value = "employeeName") String employeeName,
                                          @RequestParam(value = "ad") String ad);


    @RequestMapping(value = "/simple/{loginId}", method = HttpMethod.POST)
    Response<UserLoginModel> addByLoginId(@PathVariable("loginId") int loginId,
                                          @RequestParam(value = "employeeId") String employeeId,
                                          @RequestParam(value = "employeeName") String employeeName,
                                          @RequestParam(value = "ad") String ad);


    @RequestMapping(value = "/simple", method = HttpMethod.POST)
    Response<UserLoginModel> addUser(UserLoginModel userLoginModel);

    @RequestMapping(value = "/simple", method = HttpMethod.POST)
    HttpResult<Response<UserLoginModel>> addUser2(@RequestBody UserLoginModel userLoginModel);

    @RequestMapping(value = "/simple", method = HttpMethod.POST)
    HttpResult<Response<UserLoginModel>> addUser3(String userLoginModel);

    @RequestMapping(value = "/simple", method = HttpMethod.POST)
    HttpResult<Response<UserLoginModel>> addUser4(@RequestBody String userLoginModel);

    @RequestMapping(value = "/{path}", method = HttpMethod.POST)
    HttpResult<Response<UserLoginModel>> addUser5(@RequestBody UserLoginModel userLoginModel,
                                                  @PathVariable("path") String path,
                                                  @RequestParam(value = "employeeId") String employeeId,
                                                  @RequestParam(value = "employeeId") String employeeId2,
                                                  @RequestParam(value = "employeeId") String employeeId3,
                                                  @RequestParam(value = "employeeName") String employeeName,
                                                  @RequestParam(value = "ad") String ad);

    @RequestMapping(value = "/simple/{loginId}", method = HttpMethod.PUT)
    HttpResult<Response<UserLoginModel>> updateUser(@RequestBody UserLoginModel userLoginModel,
                                                    @PathVariable("loginId") int loginId,
                                                    @RequestParam(value = "employeeId") String employeeId,
                                                    @RequestParam(value = "employeeId") String employeeId2,
                                                    @RequestParam(value = "employeeId") String employeeId3,
                                                    @RequestParam(value = "employeeName") String employeeName,
                                                    @RequestParam(value = "ad") String ad);

    @RequestMapping(value = "/simple/{loginId}", method = HttpMethod.PATCH)
    HttpResult<Response<UserLoginModel>> patchUser(@RequestBody UserLoginModel userLoginModel,
                                                   @PathVariable("loginId") int loginId,
                                                   @RequestParam(value = "employeeId") String employeeId,
                                                   @RequestParam(value = "employeeId") String employeeId2,
                                                   @RequestParam(value = "employeeId") String employeeId3,
                                                   @RequestParam(value = "employeeName") String employeeName,
                                                   @RequestParam(value = "ad") String ad);


    @RequestMapping(value = "/simple/{loginId}", method = HttpMethod.DELETE)
    HttpResult<String> deleteUser(@RequestBody UserLoginModel userLoginModel,
                                  @PathVariable("loginId") int loginId,
                                  @RequestParam(value = "employeeId") String employeeId,
                                  @RequestParam(value = "employeeId") String employeeId2,
                                  @RequestParam(value = "employeeId") String employeeId3,
                                  @RequestParam(value = "employeeName") String employeeName,
                                  @RequestParam(value = "ad") String ad);

}

通过java 请求

HttpInvocationHandler httpInvocationHandler = new HttpInvocationHandler();
httpInvocationHandler.setRequestUrlPrefix(Consts.URL);

SimpleHttpApi simpleHttpApi = (SimpleHttpApi) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
        new Class[]{SimpleHttpApi.class},
        httpInvocationHandler);

UserLoginModel userLoginModel = new UserLoginModel();
userLoginModel.setLoginId(1);
userLoginModel.setEmployeeId("0016004");
userLoginModel.setEmployeeName("陈孝杰");
userLoginModel.setAd("xiaojie.chen");

Response<UserLoginModel> response = simpleHttpApi.addUser(userLoginModel);

System.out.println(response.getData());

通过spring xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="httpParent" class="com.chenxiaojie.http.invoker.spring.HttpProxyFactoryBean" abstract="true" init-method="init">
        <property name="invocationHandler">
            <bean class="com.chenxiaojie.http.invoker.proxy.HttpInvocationHandler">
                <property name="requestUrlPrefix" value="http://localhost:8081/httpinvoker"></property>
            </bean>
        </property>
    </bean>

    <!-- 只需配置下方代码即可 -->
    <bean id="simpleHttpApi" parent="httpParent">
        <property name="proxyInterfaces" value="com.chenxiaojie.http.invoker.test.http.api.SimpleHttpApi"/>
    </bean>
</beans>

测试类请参考com.chenxiaojie.http.invoker.test.http.test.SimpleTest

建议

如果请求量比较大, 请尽量自定义httpclient, 否则全局共享一个默认的httpclient

如果请求量比较大, 请将http请求详细日志重置到其他位置或者关闭

日志位置重置

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="info">

    <Properties>
        <Property name="log-path">/data/applogs/http-invoker-demo/logs</Property>
        <Property name="pattern">%d{yyyy-MM-dd HH:mm:ss.SSS} %level [%t] [%c] %msg%xEx%n</Property>
    </Properties>

    <Appenders>
        <Console name="ConsoleAppender" target="SYSTEM_OUT" follow="true">
            <PatternLayout pattern="${pattern}"/>
        </Console>

        <RollingFile name="AppAppender" fileName="${log-path}/app.log" filePattern="${log-path}/app.log.%d{yyyy-MM-dd}">
            <PatternLayout pattern="${pattern}"/>
            <Policies>
                <TimeBasedTriggeringPolicy interval="1"/>
            </Policies>
        </RollingFile>

        <RollingFile name="HttpAppender" fileName="${log-path}/http.log"
                     filePattern="${log-path}/http.log.%d{yyyy-MM-dd}">
            <PatternLayout pattern="${pattern}"/>
            <Policies>
                <TimeBasedTriggeringPolicy interval="1"/>
            </Policies>
        </RollingFile>

        <Async name="AsyncAppAppender">
            <AppenderRef ref="AppAppender" level="info"/>
        </Async>

    </Appenders>

    <loggers>
        <logger name="com.chenxiaojie.http.invoker.HttpInvoker$Response" additivity="false">
            <appender-ref ref="HttpAppender"/>
            <appender-ref ref="ConsoleAppender"/>
        </logger>

        <root level="info">
            <appender-ref ref="ConsoleAppender"/>
            <appender-ref ref="AsyncAppAppender"/>
        </root>
    </loggers>

</configuration>

关闭日志 spring xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="httpParent" class="com.chenxiaojie.http.invoker.spring.HttpProxyFactoryBean" abstract="true"
          init-method="init">
        <property name="invocationHandler">
            <bean class="com.chenxiaojie.http.invoker.proxy.HttpInvocationHandler">
                <property name="requestUrlPrefix" value="http://localhost:8081/httpinvoker"></property>
                <property name="openLog" value="true"></property>
            </bean>
        </property>
    </bean>

    <!-- 只需配置下方代码即可 -->
    <bean id="simpleHttpApi" parent="httpParent">
        <property name="proxyInterfaces" value="com.chenxiaojie.http.invoker.test.http.api.SimpleHttpApi"/>
    </bean>
</beans>

打包命令

mvn clean install -DskipTests -Dmaven.javadoc.skip=true

维护

有任何问题请随时联系:陈孝杰, qq:3262515, email: 3262515@qq.com

转载于:https://my.oschina.net/chenxiaojie/blog/1542258

chirui2705
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HttpInvoker简单介绍以及使用
zhang14533的博客
07-28 2715
此文章来源：https://www.cnblogs.com/lpc-xx/p/8556827.html 一、Spring HTTP Invoker简介 Spring HTTP invoker是spring框架中的一个远程调用模型，执行基于HTTP的远程调用（意味着可以通过防火墙），并使用java的序列化机制在网络间传递对象。这需要在远端和本地都使用Spring才行。客户端可以很轻松的像调用本地对象一样调用远程服务器上的对象，这有点类似于webservice，但又不同于webs...
HttpInvoker-----服务端实现
weixin_30268921的博客
01-23 160
前言 Spring开发小组意识到在RMI服务和基于HTTP的服务（如Hessian和Burlap）之间的空白。一方面，RMI使用Java标准的对象序列化，但很难穿越防火墙；另一方面。Hessian/Burlap能很好的穿过防火墙工作，但是使用自己一套的对象序列化机制。 就这样，Spring的HttpInvoker应运而生。HttpInvoker是一个新的远程调用模型，作为Spring框架的一部...
Spring HTTP invoker简介
Chinaxxren
10-26 115
核心提示：Spring HTTP invoker简介 Spring HTTP invoker是spring框架中的一个远程调用模型，执行基于HTTP的远程调用（意味着可以通过防火墙），并使用java的序列化机制在网络间传递对象。客户端可以很轻松的像调用本地对象一样调用远程服务器上的对象，这有点类似于we Spring HTTP invoker简介Spring HTTP invoker...
Spring HTTP Invoker使用介绍
weixin_34026276的博客
01-20 179
Spring HTTP Invoker一种JAVA远程方法调用框架实现，原理与JDK的RMI基本一致，所以我们先跟其它JAVA远程方法调用实现做下简单比较。RMI：使用JRMP协议(基于TCP/IP)，不允许穿透防火墙，使用JAVA系列化方式，使用于任何JAVA应用之间相互调用。Hessian：使用HTTP协议，允许穿透防火墙，使用自己的系列化方式，支持JAVA、C++、.N...
Spring httpinvoker入门教程
小半的博客
05-14 1061
httpinvoker 参考：Spring 实现远程访问详解——httpinvoker Spring httpInvoker使用标准java序列化机制，通过Http暴露业务服务。如果你的参数和返回值是比较复杂的，通过httpInvoker有巨大的优势。 远程访问流程如下 1. 服务端定义服务接口 package com.lm.core.service; import java.util.List; import com.lm.core.entity.User; publi
http-Invoker
01-29
《深入理解HTTP Invoker：构建高效HTTP客户端测试与开发实践》 HTTP Invoker，作为一款卓越的HTTP客户端测试工具，其在HTTP开发领域扮演着至关重要的角色。它为开发者提供了便利，使得发送HTTP请求变得简单易行，是...
focus-http-invoker
05-18
focus-http-invoker 此组件主要功能 1 统一http异步调用方式 2 屏蔽底层缓存碎片治理逻辑 3 主动加入appId，便于追溯调用来源 4 简明的API使用 5 将无限的网络请求折叠成有限的请求规模 引入依赖 <groupId>...
http-lambda-invoker
02-10
http-lambda-invoker 一个很小的（<20m）Docker映像，用于通过http调用lambda函数。 这是我第一次尝试golang，因此请多加注意！ 是用于开发一些lambda函数的绝佳框架，但要适应基于docker-compose的现有开发工作...
http-api-invoker:一个让http接口调用跟调用本地方法一样自然优雅的项目
05-23
HTTP接口调用框架让 HTTP 接口调用跟调用本地方法一样自然优雅将 HTTP 请求和接口绑定，然后由框架生成接口的代理类，直接调用接口的方法就会自动构建请求参数并发送请求，然后处理请求响应转换为接口方法的返回值...
faas-invoker
03-07
在提供的压缩文件`faas-invoker-main`中，很可能是faas-invoker的主要代码实现或者可执行文件。开发者可以通过分析和修改这个文件，来定制自己的函数执行逻辑，或者优化faas-invoker的行为，以适应特定的业务需求。 ...
Http Invoker (http访问测试工具)
04-19
该工具是作者为测试自己开发的基于 HTTP 协议的移动应用 API 而编写的。它的主要功能是使用用户输入网址，要提交的参数，要上传的文件等信息，向 HTTP 服务发出请求，并展示服务的返回结果。之所以没有使用 Fiddler 的 Composer 功能，是因为在我的需求中测试工具需要管理 Cookie， 而在 Fiddler 手工管理比较麻烦。
http invoker 做post测试
09-19
http invoker 在开发完http接口后可以做http post测试
httpinvoker的使用实例
06-25
里面有两个工程，一个模拟服务端，一个模拟客户端。演示了最近本的httpinvoker的使用
http-invoker插件原理解析
u014511571的博客
10-24 269
项目中不可避免的使用第三方api接口,但是如果使用apache-httpclient总是不可避免需要设置连接池等,即使每次拷贝对于项目来说也显得冗余
http invoker
worn_xiao的博客
09-10 861
1：Spring Http设计思想 最近在研究公司自己的一套rpc远程调用框架，看到其内部实现的设计思想依赖于spring的远端调用的思想，所以闲来无事，就想学习下，并记录下。 作为spring远端调用的实现，最为简单的应该是通过http调用的实现，在这种依赖中不会依赖第三方等相关组件，调用者只需要配置相关http的协议 就可以实现，简单的配置，就可以使用spring的 IOC  容器的be
HttpInvoker远程调用实例
lan_qinger的博客
07-30 1237
HttpInvoker是SpringFramework提供的远程通讯协议，只能用于JAVA程序间的通讯，且服务端和客户端必须 使用SpringFramework。 HttpInvoker 配置 服务端 web.xml &lt;!-- 远程服务 --&gt; &lt;servlet&gt; &lt;servlet-name&gt;remote&lt;/servlet-name...
Spring Http Invoker使用简介
Achiberx
10-30 1409
Spring HTTP Invoker一种JAVA远程方法调用框架实现，原理与JDK的RMI基本一致，所以我们先跟其它JAVA远程方法调用实现做下简单比较。 RMI：使用JRMP协议(基于TCP/IP)，不允许穿透防火墙，使用JAVA系列化方式，使用于任何JAVA应用之间相互调用。 Hessian：使用HTTP协议，允许穿透防火墙，使用自己的系列化方式，支持JAVA、C++、.Net等跨语言使用。
Spring 实现远程访问详解——httpinvoker
if(true){ I love it }
04-19 5532
上文我们利用Spring rmi实现了Spring的远程访问《Spring 实现远程访问详解——rmi》，本文主要讲解利用HttpInvoke实现远程访问。 Spring httpInvoker使用标准java序列化机制，通过Http暴露业务服务。如果你的参数和返回值是比较复杂的，通过httpInvoker有巨大的优势。 1. 远程访问流程 1) 服务端定义服务接口 2) 服务端实现服务接口 3) 暴露服务对象 4) 客户端定义暴露的服务端接口 5)
深入学习 Spring HttpInvoker
BRAVE
03-07 8465
深入学习 Spring HttpInvoker 远程通信协议 RPC 远程过程调用，是一个计算机通信协议，允许一台计算机的程序，调用另一台计算机的子程序。如果涉及到的软件采用面向对象编程，亦可称为远程方法调用（如 Java RMI） RMI 一般指Java RMI (Java Remote Method Invocation) Java远程方法调用，只适用于Java程序之间的通...
instanceof Invoker
最新发布
07-28
- *1* *2* [Spring的HTTPInvoker](https://blog.csdn.net/weixin_35843830/article/details/114524139)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值