聊聊spring cloud的FeignLoadBalancer

public class FeignLoadBalancer extends
AbstractLoadBalancerAwareClient<FeignLoadBalancer.RibbonRequest, FeignLoadBalancer.RibbonResponse> {

private final RibbonProperties ribbon;

protected int connectTimeout;

protected int readTimeout;

protected IClientConfig clientConfig;

protected ServerIntrospector serverIntrospector;

public FeignLoadBalancer(ILoadBalancer lb, IClientConfig clientConfig,
ServerIntrospector serverIntrospector) {
super(lb, clientConfig);
this.setRetryHandler(RetryHandler.DEFAULT);
this.clientConfig = clientConfig;
this.ribbon = RibbonProperties.from(clientConfig);
RibbonProperties ribbon = this.ribbon;
this.connectTimeout = ribbon.getConnectTimeout();
this.readTimeout = ribbon.getReadTimeout();
this.serverIntrospector = serverIntrospector;
}

@Override
public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)
throws IOException {
Request.Options options;
if (configOverride != null) {
RibbonProperties override = RibbonProperties.from(configOverride);
options = new Request.Options(override.connectTimeout(this.connectTimeout),
override.readTimeout(this.readTimeout));
}
else {
options = new Request.Options(this.connectTimeout, this.readTimeout);
}
Response response = request.client().execute(request.toRequest(), options);
return new RibbonResponse(request.getUri(), response);
}

@Override
public RequestSpecificRetryHandler getRequestSpecificRetryHandler(
RibbonRequest request, IClientConfig requestConfig) {
if (this.ribbon.isOkToRetryOnAllOperations()) {
return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(),
requestConfig);
}
if (!request.toRequest().httpMethod().name().equals("GET")) {
return new RequestSpecificRetryHandler(true, false, this.getRetryHandler(),
requestConfig);
}
else {
return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(),
requestConfig);
}
}

@Override
public URI reconstructURIWithServer(Server server, URI original) {
URI uri = updateToSecureConnectionIfNeeded(original, this.clientConfig,
this.serverIntrospector, server);
return super.reconstructURIWithServer(server, uri);
}

//......
}

protected static class RibbonRequest extends ClientRequest implements Cloneable {

private final Request request;

private final Client client;

protected RibbonRequest(Client client, Request request, URI uri) {
this.client = client;
setUri(uri);
this.request = toRequest(request);
}

private Request toRequest(Request request) {
Map<String, Collection<String>> headers = new LinkedHashMap<>(
request.headers());
return Request.create(request.httpMethod(), getUri().toASCIIString(), headers,
request.requestBody());
}

Request toRequest() {
return toRequest(this.request);
}

Client client() {
return this.client;
}

HttpRequest toHttpRequest() {
return new HttpRequest() {
@Override
public HttpMethod getMethod() {
return HttpMethod
.resolve(RibbonRequest.this.toRequest().httpMethod().name());
}

@Override
public String getMethodValue() {
return getMethod().name();
}

@Override
public URI getURI() {
return RibbonRequest.this.getUri();
}

@Override
public HttpHeaders getHeaders() {
Map<String, List<String>> headers = new HashMap<>();
Map<String, Collection<String>> feignHeaders = RibbonRequest.this
.toRequest().headers();
for (String key : feignHeaders.keySet()) {
headers.put(key, new ArrayList<String>(feignHeaders.get(key)));
}
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.putAll(headers);
return httpHeaders;

}
};
}

public Request getRequest() {
return this.request;
}

public Client getClient() {
return this.client;
}

@Override
public Object clone() {
return new RibbonRequest(this.client, this.request, getUri());
}

}

protected static class RibbonResponse implements IResponse {

private final URI uri;

private final Response response;

protected RibbonResponse(URI uri, Response response) {
this.uri = uri;
this.response = response;
}

@Override
public Object getPayload() throws ClientException {
return this.response.body();
}

@Override
public boolean hasPayload() {
return this.response.body() != null;
}

@Override
public boolean isSuccess() {
return this.response.status() == 200;
}

@Override
public URI getRequestedURI() {
return this.uri;
}

@Override
public Map<String, Collection<String>> getHeaders() {
return this.response.headers();
}

Response toResponse() {
return this.response;
}

@Override
public void close() throws IOException {
if (this.response != null && this.response.body() != null) {
this.response.body().close();
}
}

}