请问大神,为啥我用feign+okhttp 性能比http都低很多?

发布于 2021-12-04 02:07:22 字数 2077 浏览 1048 评论 4

@秋雨霏霏 你好,想跟你请教个问题:

我没有用@FeignClient注解,直接Autowired Client;

如下:

@Autowired
private Client client;
////////////////
//LoadBalancerFeignClient执行,不走@feignclient标签
Map<String, Collection> headers = SpringCloudUtils.toCollectionHeaders(header);
StringBuilder builder = new StringBuilder();
builder.append("http://").append(cloudRequestConfig.getApplicationName())
.append("/").append(cloudRequestConfig.getRootUri())
.append("/").append(cloudRequestConfig.getUri());
LOGGER.info( "url:" + builder.toString());
//String url = "http://"+openApiSpringCloudRequestConfig.getApplicationName()+"/"+openApiSpringCloudRequestConfig.getSysCode()+"/"+openApiSpringCloudRequestConfig.getReqMethod();
int connectTimeoutMillis = Integer.parseInt(cloudRequestConfig.getConnectionTimeOut()) ;
int readTimeoutMillis = Integer.parseInt(cloudRequestConfig.getReadTimeOut()) ;
Object params = apiRequest.getRequestParam2String();
byte[] hessianBody = SpringCloudUtils.serializeHessian(cloudRequestConfig.getDesMethod(), params);
Request request = Request.create(cloudRequestConfig.getMethodType(), builder.toString(),
headers, hessianBody, chrset);
long cloudPrepareDownCost = System.currentTimeMillis()-cloudPrepareUpStartTime;
LOGGER.info( "cloudPrepareDownCost:" + cloudPrepareDownCost);
Response response = client.execute(request, new Options());
//Response response = client.execute(request, new Options(connectTimeoutMillis, readTimeoutMillis));
long cloudAlmostCost = System.currentTimeMillis()-cloudPrepareUpStartTime;
LOGGER.info("cloudAlmostCost: "+cloudAlmostCost);

 

我测试了下。200个并发,30分钟,cloudAlmostCost 最大8624毫秒(cloudPrepareDownCost不耗时间),同样的条件下,我用http,最大耗时1702毫秒,为啥?百度没有搜到多少关于springcloud性能的资料

 

 

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(4

刘备忘录 2021-12-09 12:49:00

其他问题导致,已修复!

反目相谮 2021-12-09 03:26:34

试试 #Jboot#

丢了幸福的猪 2021-12-09 01:30:18

客户端

package com.pa.openapi.netway.front.controllers;

import java.io.IOException;
import java.net.URI;
import java.nio.charset.Charset;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
import org.springframework.cloud.netflix.feign.ribbon.CachingSpringLoadBalancerFactory;
import org.springframework.cloud.netflix.feign.ribbon.FeignLoadBalancer;
import org.springframework.cloud.netflix.feign.ribbon.LoadBalancerFeignClient;
import org.springframework.cloud.netflix.feign.ribbon.RetryableFeignLoadBalancer;
import org.springframework.cloud.netflix.ribbon.DefaultServerIntrospector;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
import org.springframework.cloud.zookeeper.discovery.ZookeeperInstance;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.netflix.client.ClientFactory;
import com.netflix.client.RequestSpecificRetryHandler;
import com.netflix.client.config.IClientConfig;
import com.netflix.config.ChainedDynamicProperty;
import com.netflix.loadbalancer.BaseLoadBalancer;
import com.netflix.loadbalancer.DynamicServerListLoadBalancer;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.LoadBalancerContext;
import com.netflix.loadbalancer.Server;
import com.netflix.loadbalancer.reactive.LoadBalancerCommand;
import com.netflix.loadbalancer.reactive.LoadBalancerCommand.Builder;
import com.pa.openapi.module.entity.OpenApiSpringCloudRequestConfig;
import com.pa.openapi.module.utils.BeanHelper;
import com.pa.openapi.netgate.common.constants.ResponseCodeDesc;
import com.pa.openapi.netgate.common.exception.OpenApiException;
import com.pa.openapi.netway.front.ProcessFeignClient;
import com.pa.openapi.netway.front.interceptors.AddLogTraceIdFilter;

import feign.Client;
import feign.Request;
import feign.Util;
import feign.okhttp.OkHttpClient;
import feign.Request.Options;
import feign.Response;
@RestController
public class SpringCloudController {

    private static final Logger LOGGER = LoggerFactory.getLogger(SpringCloudController.class);
    
    @Autowired
    private Client client;
    
    
    @Autowired
    private SpringClientFactory clientFactory;
    
    @Autowired
    private DiscoveryClient discovery;
    
    @Autowired
    private ProcessFeignClient processFeignClient;
    @RequestMapping("testFeignClient")
    public Object testFeignClient() {
        String logTraceId = MDC.get(AddLogTraceIdFilter.LOG_TRACEID);
        Map<String, String> header = new HashMap<String, String>();
        if (StringUtils.isNotBlank(logTraceId)) {
            header.put("logTraceId", logTraceId);
        }
        
        long feignClientStartTime = System.currentTimeMillis();
        Object result = processFeignClient.doProcess(logTraceId);
        long feignClientCostTime = System.currentTimeMillis()-feignClientStartTime;
        LOGGER.info( "feignClientCostTime:" + feignClientCostTime);
        return result;
    }
    
    @RequestMapping("testNonFeignClient")
    public Object testNonFeignClient() throws Exception {
        Object responseStr = null;
        String logTraceId = MDC.get(AddLogTraceIdFilter.LOG_TRACEID);
        String url = "http://"+"OpenAPIApp/OpenAPIApp/test/test";
        //String url = "http://"+"openapi-gateway-core/openapi-gateway-core/test/test";
        Map<String, String> header = new HashMap<String, String>();
        if (StringUtils.isNotBlank(logTraceId)) {
            header.put("logTraceId", logTraceId);
        }
        Map<String, Collection<String>> headers = SpringCloudUtils.toCollectionHeaders(header);
        Request request = Request.create("POST", url, 
                headers, null, chrset);
        try {
            long nonFeignClientStartTime = System.currentTimeMillis();
            Response response = client.execute(request, new Options());
            long nonFeignClientCostTime = System.currentTimeMillis()-nonFeignClientStartTime;
            LOGGER.info( "nonFeignClientCostTime:" + nonFeignClientCostTime);
            if (response.status() >= 200 && response.status() < 300 && response.body()!= null) {
                responseStr = IOUtils.toString(response.body().asInputStream(), "UTF-8");
                LOGGER.info( "responseStr:" + responseStr);
            }else if (response.status() == 404) {
                LOGGER.error("http response status is 404,returned status is:"
                        + response.status());
                throw new OpenApiException(ResponseCodeDesc.SYS_THIRD_HTTPSTATUS_UN200_CODE);
            } else {
                LOGGER.error("http response status is not 200,returned status is:"
                        + response.status());
                throw new OpenApiException(ResponseCodeDesc.SYS_THIRD_HTTPSTATUS_UN200_CODE);
            }
        } catch (OpenApiException e) {
            LOGGER.error(e.getMessage(),e);
            throw new OpenApiException(ResponseCodeDesc.SYS_ERR_CODE);
        }catch (Exception e) {
            LOGGER.error(e.getMessage(),e);
        }
        return responseStr;
    }
    
    private static final Charset chrset = Charset.forName("Utf-8");
     @RequestMapping("/all")  
        public Object all() {  
         LOGGER.info(discovery.getServices().toString());  
            return "all";  
        }  
    @RequestMapping("/feign/localTest")
    public String localTestFeign(){
        OpenApiSpringCloudRequestConfig cloudRequestConfig = new OpenApiSpringCloudRequestConfig();
        cloudRequestConfig.setApplicationName("openapi-gateway-core");
        cloudRequestConfig.setConnectionTimeOut("50000");
        cloudRequestConfig.setReadTimeOut("50000");
        cloudRequestConfig.setMethodType("GET");
        cloudRequestConfig.setReqMethod("test");
        cloudRequestConfig.setSysCode("feign");
        cloudRequestConfig.setRootUri("openapi-gateway-core");
        cloudRequestConfig.setUri("feign/test");
        cloudRequestConfig.setRetryer("5");
        return execute(cloudRequestConfig);
    }
    
    @RequestMapping("/feign/serverTest")
    public String serverTestFeign(){
        OpenApiSpringCloudRequestConfig cloudRequestConfig = new OpenApiSpringCloudRequestConfig();
        cloudRequestConfig.setApplicationName("openapi-gateway-core");
        cloudRequestConfig.setConnectionTimeOut("50000");
        cloudRequestConfig.setReadTimeOut("50000");
        cloudRequestConfig.setMethodType("GET");
        cloudRequestConfig.setReqMethod("test");
        cloudRequestConfig.setSysCode("feign");
        cloudRequestConfig.setRootUri("OpenAPIApp");
        cloudRequestConfig.setUri("feign/test");
        cloudRequestConfig.setRetryer("5");
        return execute(cloudRequestConfig);
    }
    
    public String execute(OpenApiSpringCloudRequestConfig cloudRequestConfig) {
        String responseStr = null;
        try {
        Map<String, Collection<String>> headers =
                  new LinkedHashMap<String, Collection<String>>();
        StringBuilder builder = new StringBuilder();
        builder.append("http://").append(cloudRequestConfig.getApplicationName())
            .append("/").append(cloudRequestConfig.getRootUri())
                .append("/").append(cloudRequestConfig.getUri());
        //String url = "http://"+openApiSpringCloudRequestConfig.getApplicationName()+"/"+openApiSpringCloudRequestConfig.getSysCode()+"/"+openApiSpringCloudRequestConfig.getReqMethod();
        int connectTimeoutMillis = Integer.parseInt(cloudRequestConfig.getConnectionTimeOut()) ;
        int readTimeoutMillis = Integer.parseInt(cloudRequestConfig.getReadTimeOut()) ;
        
        BaseLoadBalancer lb =  (BaseLoadBalancer) clientFactory.getLoadBalancer("openapi-gateway-core");
        
        
        //LoadBalancingTarget<ILoadBalancer> target =(LoadBalancingTarget<ILoadBalancer>) LoadBalancingTarget.create(clientFactory.getLoadBalancer("openapi-gateway-core").getClass(), "http://"+cloudRequestConfig.getApplicationName());
        
        Request request = Request.create(cloudRequestConfig.getMethodType(), builder.toString(), headers, null, chrset);
//        CachingSpringLoadBalancerFactory lbClientFactory = new CachingSpringLoadBalancerFactory(clientFactory);
//        LoadBalancerFeignClient loadBalancerFeignClient = new LoadBalancerFeignClient(client,lbClientFactory,clientFactory);
//        Response response = loadBalancerFeignClient.execute(request, new Options(connectTimeoutMillis, readTimeoutMillis));
        Response response = client.execute(request, new Options(connectTimeoutMillis, readTimeoutMillis));
        if (response.status() >= 200 && response.status() < 300) {
            byte[] bodyData = Util.toByteArray(response.body().asInputStream());
            responseStr = new String(bodyData, chrset);
            LOGGER.info( "responseStr:" + responseStr);
        }else if (response.status() == 404) {
            throw new Exception("http response status is 404,returned status is:"
                    + response.status());
        } else {
            throw new Exception("http response status is not 200,returned status is:"
                    + response.status());
        }
        LoadBalancerContext loadBalancerContext = new LoadBalancerContext(lb);
        Server server = loadBalancerContext.getServerFromLoadBalancer(URI.create("http:///openapi-gateway-core/feign/test"), null);
        LOGGER.info( "server:" + server.getHostPort());
        } catch (Exception e) {
        LOGGER.error(e.getMessage(), e);
    }
        return responseStr;
    }
    
}
 

 

---------------------------

package com.pa.openapi.netway.front;

import java.util.Map;

import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import feign.HeaderMap;

@Component
@FeignClient("OpenAPIApp")
public interface ProcessFeignClient {
    //OpenAPIApp
    @RequestMapping(value = "/OpenAPIApp/test/test", method = RequestMethod.POST,consumes= MediaType.APPLICATION_JSON_VALUE)
    public Object doProcess(@RequestHeader("logTraceId") String logTraceId );
}
 

 

 

用的是zookeeper注册,注册两个服务,没有引入hystrix包,分别做了用@FeignClient注解和拆掉注解后的方式,服务端收到请求,啥都没有,立马返回。

谢绝鈎搭 2021-12-08 06:05:00

有没有完整的测试用例,或者通过码云看看

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文