class HeaderInterceptor implements Interceptor {
 
 private static final String ENCODING_GZIP = "gzip";
 private static final String CONTENT_TYPE_JSON = "application/json;charset=UTF-8";
 private static final String HEADER_CONTENT_TYPE = "Content-Type";
 private static final String HEADER_ACCEPT_TYPE = "application/json";
 private static final String HEADER_CONTENT_ENCODING = "Content-Encoding";
 private final static String CHARSET = "UTF-8";
 
 @Override
 public Response intercept(Chain chain) throws IOException {
  Request originRequest = chain.request();
  Request.Builder newBuilder = originRequest.newBuilder();
  newBuilder.addHeader("Accept", HEADER_ACCEPT_TYPE);
  newBuilder.addHeader("Accept-Charset", CHARSET);
  newBuilder.addHeader("Accept-Encoding", ENCODING_GZIP);
  newBuilder.addHeader("Accept-Language", Locale.getDefault().toString().replace("_", "-"));
  newBuilder.addHeader(HEADER_CONTENT_TYPE, CONTENT_TYPE_JSON);
  return chain.proceed(newBuilder.build());
 }
}

Request originRequest = chain.request();
if (paramsMap != null) {
 HttpUrl originUrl = originRequest.url();
 HttpUrl.Builder newBuilder = originUrl.newBuilder();
 for (String key : paramsMap.keySet()) {
  newBuilder.addEncodedQueryParameter(key, paramsMap.get(key));
 }
 HttpUrl newUrl = newBuilder.build();
 Request newRequest = originRequest.newBuilder().url(newUrl).build();
 return chain.proceed(newRequest);
}
return chain.proceed(originRequest);

interface HostName {
 String CLOUD = "CLOUD";
 String PRIVATE = "PRIVATE";
 String DEV = "DEV";
}
 
interface HostValue {
 String CLOUD = "https://www.baidu.com";
 String PRIVATE = "https://private.bidu.com";
 String DEV = "https://dev.baidu.com";
}

interface RestVersionCode {
 String EMPTY = "EMPTY";
 String V1 = "V1";
 String V2 = "V2";
 String PRIVATE = "PRIVATE";
}
 
/**
 * path 前綴值
 */
interface RestVersionValue {
 String EMPTY = "";
 String V1 = "rest/v1";
 String V2 = "rest/v2";
 String PRIVATE = "rest/private";
}

interface BaiduApiService {
 
 @GET("s")
 Observable<Response<Object>> search(@Query("wd")String wd);
 
 @GET("s")
 @Headers({UrlConstants.Header.REST_VERSION_V1})
 Observable<Response<Object>> searchChangePath(@Query("wd")String wd);
 
 @GET("s")
 @Headers({UrlConstants.Header.HOST_DEV})
 Observable<Response<Object>> searchChangeHost(@Query("wd")String wd);
 
 @Headers({UrlConstants.Header.HOST_PRIVATE, UrlConstants.Header.REST_VERSION_PRIVATE})
 @GET("s")
 Observable<Response<Object>> searchChangeHostPath(@Query("wd")String wd);
}

interface Header {
 String SPLIT_COLON = ":";
 String HOST = "HostName";
 String HOST_CLOUD = HOST + SPLIT_COLON + HostName.CLOUD;
 String HOST_PRIVATE = HOST + SPLIT_COLON + HostName.PRIVATE;
 String HOST_DEV = HOST + SPLIT_COLON + HostName.DEV;
 String REST_VERSION = "RestVersion";
 String REST_VERSION_V1 = REST_VERSION + SPLIT_COLON + RestVersionCode.V1;
 String REST_VERSION_V2 = REST_VERSION + SPLIT_COLON + RestVersionCode.V2;
 String REST_VERSION_PRIVATE = REST_VERSION + SPLIT_COLON + RestVersionCode.PRIVATE;
 String REST_VERSION_EMPTY = REST_VERSION + SPLIT_COLON + RestVersionCode.EMPTY;
}

class RequestInterceptor implements Interceptor {
 
 @Override
 public Response intercept(Chain chain) throws IOException {
  Request originRequest = chain.request();
  HttpUrl originUrl = originRequest.url();
  HttpUrl.Builder newBuilder;
 
  String hostType = originRequest.header(UrlConstants.Header.HOST);
  System.out.println("hostType:" + hostType);
  if (hostType != null && hostType.length() > 0) {
   String hostValue = UrlManager.getInstance().getHost(hostType);
   HttpUrl temp = HttpUrl.parse(hostValue);
   if (temp == null) {
    throw new IllegalArgumentException(hostType + "對應的host地址不合法:" + hostValue);
   }
   newBuilder = temp.newBuilder();
  } else {
   newBuilder = new HttpUrl.Builder()
     .scheme(originUrl.scheme())
     .host(originUrl.host())
     .port(originUrl.port());
  }
  String restVersion = originRequest.header(UrlConstants.Header.REST_VERSION);
  System.out.println("restVersion:" + restVersion);
  if (restVersion == null) {
   restVersion = UrlConstants.RestVersionCode.V2;
  }
  String restValue = UrlManager.getInstance().getRest(restVersion);
  if (restValue.contains("/")) {
   String[] paths = restValue.split("/");
   for (String path : paths) {
    newBuilder.addEncodedPathSegment(path);
   }
  } else {
   newBuilder.addEncodedPathSegment(restValue);
  }
  for (int i = 0; i < originUrl.pathSegments().size(); i++) {
   newBuilder.addEncodedPathSegment(originUrl.encodedPathSegments().get(i));
  }
 
  newBuilder.encodedPassword(originUrl.encodedPassword())
    .encodedUsername(originUrl.encodedUsername())
    .encodedQuery(originUrl.encodedQuery())
    .encodedFragment(originUrl.encodedFragment());
 
  HttpUrl newUrl = newBuilder.build();
  System.out.println("newUrl:" + newUrl.toString());
  Request newRequest = originRequest.newBuilder().url(newUrl).build();
  return chain.proceed(newRequest);
 }
}

private Map<String, String> hostMap;
private Map<String, String> restMap;
 
private UrlManager() {
 hostMap = new HashMap<>(16);
 for (UrlConstants.Host host : UrlConstants.Host.values()) {
  hostMap.put(host.getName(), host.getValue());
 }
 restMap = new HashMap<>();
 for (UrlConstants.Rest rest : UrlConstants.Rest.values()) {
  restMap.put(rest.getVersion(), rest.getValue());
 }
}
 
//更新host 的值
public void setHost(String name, String value) {
 if (hostMap.containsKey(name)) {
  HttpUrl httpUrl = HttpUrl.parse(value);
  if (httpUrl == null) {
   throw new IllegalArgumentException("要存入的Host " + name + "對應的value:"
     + value + "不合法!");
  }
  hostMap.put(name, value);
 } else {
  throw new NoSuchElementException("沒有找到已經(jīng)定義的Host名稱:" + name + ",請先在" +
    "net.devwiki.manager.UrlConstants.Host中定義!");
 }
}
 
//根據(jù)host 獲取值
public String getHost(String name) {
 if (!hostMap.containsKey(name)) {
  throw new NoSuchElementException("沒有找到已經(jīng)定義的Host名稱:" + name + ",請先在" +
    "net.devwiki.manager.UrlConstants.Host中定義!");
 }
 return hostMap.get(name);
}

private static void testRequest() {
 BaiduRest rest = new BaiduRest();
 
 testDefault(rest);
 
 testChangeHost(rest);
 
 testChangePath(rest);
 
 testChangeHostPath(rest);
}