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

Question

@秋雨霏霏 你好，想跟你请教个问题：

我没有用@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性能的资料

 

 

Answer 1

其他问题导致，已修复！

Answer 2

试试 #Jboot#

Answer 3

客户端

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注解和拆掉注解后的方式，服务端收到请求，啥都没有，立马返回。

Answer 4

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