SpringCloud 源碼系列(5)—— 負載均衡 Ribbon(下)
- 2020 年 12 月 25 日
- 筆記
- RestTemplate, RetryTemplate, ribbon, 請求重試, 負載均衡
SpringCloud 源碼系列(4)—— 負載均衡 Ribbon(上)
SpringCloud 源碼系列(5)—— 負載均衡 Ribbon(下)
五、Ribbon 核心介面
前面已經了解到 Ribbon 核心介面以及默認實現如何協作來查找要調用的一個實例,這節再來看下各個核心介面的一些特性及其它實現類。
1、客戶端配置 — IClientConfig
IClientConfig 就是管理客戶端配置的核心介面,它的默認實現類是 DefaultClientConfigImpl。可以看到在創建 IClientConfig 時,設置了 Ribbon 客戶端默認的連接和讀取超時時間為 1 秒,例如讀取如果超過1秒,就會返回超時,這兩個一般需要根據實際情況來調整。、
1 @Bean 2 @ConditionalOnMissingBean 3 public IClientConfig ribbonClientConfig() { 4 DefaultClientConfigImpl config = new DefaultClientConfigImpl(); 5 // 載入配置 6 config.loadProperties(this.name); 7 // 連接超時默認 1 秒 8 config.set(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT); 9 // 讀取超時默認 1 秒 10 config.set(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT); 11 config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD); 12 return config; 13 }
CommonClientConfigKey 這個類定義了 Ribbon 客戶端相關的所有配置的鍵常量,可以通過這個類來看有哪些配置。


1 public abstract class CommonClientConfigKey<T> implements IClientConfigKey<T> { 2 3 public static final IClientConfigKey<String> AppName = new CommonClientConfigKey<String>("AppName"){}; 4 5 public static final IClientConfigKey<String> Version = new CommonClientConfigKey<String>("Version"){}; 6 7 public static final IClientConfigKey<Integer> Port = new CommonClientConfigKey<Integer>("Port"){}; 8 9 public static final IClientConfigKey<Integer> SecurePort = new CommonClientConfigKey<Integer>("SecurePort"){}; 10 11 public static final IClientConfigKey<String> VipAddress = new CommonClientConfigKey<String>("VipAddress"){}; 12 13 public static final IClientConfigKey<Boolean> ForceClientPortConfiguration = new CommonClientConfigKey<Boolean>("ForceClientPortConfiguration"){}; // use client defined port regardless of server advert 14 15 public static final IClientConfigKey<String> DeploymentContextBasedVipAddresses = new CommonClientConfigKey<String>("DeploymentContextBasedVipAddresses"){}; 16 17 public static final IClientConfigKey<Integer> MaxAutoRetries = new CommonClientConfigKey<Integer>("MaxAutoRetries"){}; 18 19 public static final IClientConfigKey<Integer> MaxAutoRetriesNextServer = new CommonClientConfigKey<Integer>("MaxAutoRetriesNextServer"){}; 20 21 public static final IClientConfigKey<Boolean> OkToRetryOnAllOperations = new CommonClientConfigKey<Boolean>("OkToRetryOnAllOperations"){}; 22 23 public static final IClientConfigKey<Boolean> RequestSpecificRetryOn = new CommonClientConfigKey<Boolean>("RequestSpecificRetryOn"){}; 24 25 public static final IClientConfigKey<Integer> ReceiveBufferSize = new CommonClientConfigKey<Integer>("ReceiveBufferSize"){}; 26 27 public static final IClientConfigKey<Boolean> EnablePrimeConnections = new CommonClientConfigKey<Boolean>("EnablePrimeConnections"){}; 28 29 public static final IClientConfigKey<String> PrimeConnectionsClassName = new CommonClientConfigKey<String>("PrimeConnectionsClassName"){}; 30 31 public static final IClientConfigKey<Integer> MaxRetriesPerServerPrimeConnection = new CommonClientConfigKey<Integer>("MaxRetriesPerServerPrimeConnection"){}; 32 33 public static final IClientConfigKey<Integer> MaxTotalTimeToPrimeConnections = new CommonClientConfigKey<Integer>("MaxTotalTimeToPrimeConnections"){}; 34 35 public static final IClientConfigKey<Float> MinPrimeConnectionsRatio = new CommonClientConfigKey<Float>("MinPrimeConnectionsRatio"){}; 36 37 public static final IClientConfigKey<String> PrimeConnectionsURI = new CommonClientConfigKey<String>("PrimeConnectionsURI"){}; 38 39 public static final IClientConfigKey<Integer> PoolMaxThreads = new CommonClientConfigKey<Integer>("PoolMaxThreads"){}; 40 41 public static final IClientConfigKey<Integer> PoolMinThreads = new CommonClientConfigKey<Integer>("PoolMinThreads"){}; 42 43 public static final IClientConfigKey<Integer> PoolKeepAliveTime = new CommonClientConfigKey<Integer>("PoolKeepAliveTime"){}; 44 45 public static final IClientConfigKey<String> PoolKeepAliveTimeUnits = new CommonClientConfigKey<String>("PoolKeepAliveTimeUnits"){}; 46 47 public static final IClientConfigKey<Boolean> EnableConnectionPool = new CommonClientConfigKey<Boolean>("EnableConnectionPool") {}; 48 49 /** 50 * Use {@link #MaxConnectionsPerHost} 51 */ 52 @Deprecated 53 public static final IClientConfigKey<Integer> MaxHttpConnectionsPerHost = new CommonClientConfigKey<Integer>("MaxHttpConnectionsPerHost"){}; 54 55 /** 56 * Use {@link #MaxTotalConnections} 57 */ 58 @Deprecated 59 public static final IClientConfigKey<Integer> MaxTotalHttpConnections = new CommonClientConfigKey<Integer>("MaxTotalHttpConnections"){}; 60 61 public static final IClientConfigKey<Integer> MaxConnectionsPerHost = new CommonClientConfigKey<Integer>("MaxConnectionsPerHost"){}; 62 63 public static final IClientConfigKey<Integer> MaxTotalConnections = new CommonClientConfigKey<Integer>("MaxTotalConnections"){}; 64 65 public static final IClientConfigKey<Boolean> IsSecure = new CommonClientConfigKey<Boolean>("IsSecure"){}; 66 67 public static final IClientConfigKey<Boolean> GZipPayload = new CommonClientConfigKey<Boolean>("GZipPayload"){}; 68 69 public static final IClientConfigKey<Integer> ConnectTimeout = new CommonClientConfigKey<Integer>("ConnectTimeout"){}; 70 71 public static final IClientConfigKey<Integer> BackoffInterval = new CommonClientConfigKey<Integer>("BackoffTimeout"){}; 72 73 public static final IClientConfigKey<Integer> ReadTimeout = new CommonClientConfigKey<Integer>("ReadTimeout"){}; 74 75 public static final IClientConfigKey<Integer> SendBufferSize = new CommonClientConfigKey<Integer>("SendBufferSize"){}; 76 77 public static final IClientConfigKey<Boolean> StaleCheckingEnabled = new CommonClientConfigKey<Boolean>("StaleCheckingEnabled"){}; 78 79 public static final IClientConfigKey<Integer> Linger = new CommonClientConfigKey<Integer>("Linger"){}; 80 81 public static final IClientConfigKey<Integer> ConnectionManagerTimeout = new CommonClientConfigKey<Integer>("ConnectionManagerTimeout"){}; 82 83 public static final IClientConfigKey<Boolean> FollowRedirects = new CommonClientConfigKey<Boolean>("FollowRedirects"){}; 84 85 public static final IClientConfigKey<Boolean> ConnectionPoolCleanerTaskEnabled = new CommonClientConfigKey<Boolean>("ConnectionPoolCleanerTaskEnabled"){}; 86 87 public static final IClientConfigKey<Integer> ConnIdleEvictTimeMilliSeconds = new CommonClientConfigKey<Integer>("ConnIdleEvictTimeMilliSeconds"){}; 88 89 public static final IClientConfigKey<Integer> ConnectionCleanerRepeatInterval = new CommonClientConfigKey<Integer>("ConnectionCleanerRepeatInterval"){}; 90 91 public static final IClientConfigKey<Boolean> EnableGZIPContentEncodingFilter = new CommonClientConfigKey<Boolean>("EnableGZIPContentEncodingFilter"){}; 92 93 public static final IClientConfigKey<String> ProxyHost = new CommonClientConfigKey<String>("ProxyHost"){}; 94 95 public static final IClientConfigKey<Integer> ProxyPort = new CommonClientConfigKey<Integer>("ProxyPort"){}; 96 97 public static final IClientConfigKey<String> KeyStore = new CommonClientConfigKey<String>("KeyStore"){}; 98 99 public static final IClientConfigKey<String> KeyStorePassword = new CommonClientConfigKey<String>("KeyStorePassword"){}; 100 101 public static final IClientConfigKey<String> TrustStore = new CommonClientConfigKey<String>("TrustStore"){}; 102 103 public static final IClientConfigKey<String> TrustStorePassword = new CommonClientConfigKey<String>("TrustStorePassword"){}; 104 105 // if this is a secure rest client, must we use client auth too? 106 public static final IClientConfigKey<Boolean> IsClientAuthRequired = new CommonClientConfigKey<Boolean>("IsClientAuthRequired"){}; 107 108 public static final IClientConfigKey<String> CustomSSLSocketFactoryClassName = new CommonClientConfigKey<String>("CustomSSLSocketFactoryClassName"){}; 109 // must host name match name in certificate? 110 public static final IClientConfigKey<Boolean> IsHostnameValidationRequired = new CommonClientConfigKey<Boolean>("IsHostnameValidationRequired"){}; 111 112 // see also //hc.apache.org/httpcomponents-client-ga/tutorial/html/advanced.html 113 public static final IClientConfigKey<Boolean> IgnoreUserTokenInConnectionPoolForSecureClient = new CommonClientConfigKey<Boolean>("IgnoreUserTokenInConnectionPoolForSecureClient"){}; 114 115 // Client implementation 116 public static final IClientConfigKey<String> ClientClassName = new CommonClientConfigKey<String>("ClientClassName"){}; 117 118 //LoadBalancer Related 119 public static final IClientConfigKey<Boolean> InitializeNFLoadBalancer = new CommonClientConfigKey<Boolean>("InitializeNFLoadBalancer"){}; 120 121 public static final IClientConfigKey<String> NFLoadBalancerClassName = new CommonClientConfigKey<String>("NFLoadBalancerClassName"){}; 122 123 public static final IClientConfigKey<String> NFLoadBalancerRuleClassName = new CommonClientConfigKey<String>("NFLoadBalancerRuleClassName"){}; 124 125 public static final IClientConfigKey<String> NFLoadBalancerPingClassName = new CommonClientConfigKey<String>("NFLoadBalancerPingClassName"){}; 126 127 public static final IClientConfigKey<Integer> NFLoadBalancerPingInterval = new CommonClientConfigKey<Integer>("NFLoadBalancerPingInterval"){}; 128 129 public static final IClientConfigKey<Integer> NFLoadBalancerMaxTotalPingTime = new CommonClientConfigKey<Integer>("NFLoadBalancerMaxTotalPingTime"){}; 130 131 public static final IClientConfigKey<String> NFLoadBalancerStatsClassName = new CommonClientConfigKey<String>("NFLoadBalancerStatsClassName"){}; 132 133 public static final IClientConfigKey<String> NIWSServerListClassName = new CommonClientConfigKey<String>("NIWSServerListClassName"){}; 134 135 public static final IClientConfigKey<String> ServerListUpdaterClassName = new CommonClientConfigKey<String>("ServerListUpdaterClassName"){}; 136 137 public static final IClientConfigKey<String> NIWSServerListFilterClassName = new CommonClientConfigKey<String>("NIWSServerListFilterClassName"){}; 138 139 public static final IClientConfigKey<Integer> ServerListRefreshInterval = new CommonClientConfigKey<Integer>("ServerListRefreshInterval"){}; 140 141 public static final IClientConfigKey<Boolean> EnableMarkingServerDownOnReachingFailureLimit = new CommonClientConfigKey<Boolean>("EnableMarkingServerDownOnReachingFailureLimit"){}; 142 143 public static final IClientConfigKey<Integer> ServerDownFailureLimit = new CommonClientConfigKey<Integer>("ServerDownFailureLimit"){}; 144 145 public static final IClientConfigKey<Integer> ServerDownStatWindowInMillis = new CommonClientConfigKey<Integer>("ServerDownStatWindowInMillis"){}; 146 147 public static final IClientConfigKey<Boolean> EnableZoneAffinity = new CommonClientConfigKey<Boolean>("EnableZoneAffinity"){}; 148 149 public static final IClientConfigKey<Boolean> EnableZoneExclusivity = new CommonClientConfigKey<Boolean>("EnableZoneExclusivity"){}; 150 151 public static final IClientConfigKey<Boolean> PrioritizeVipAddressBasedServers = new CommonClientConfigKey<Boolean>("PrioritizeVipAddressBasedServers"){}; 152 153 public static final IClientConfigKey<String> VipAddressResolverClassName = new CommonClientConfigKey<String>("VipAddressResolverClassName"){}; 154 155 public static final IClientConfigKey<String> TargetRegion = new CommonClientConfigKey<String>("TargetRegion"){}; 156 157 public static final IClientConfigKey<String> RulePredicateClasses = new CommonClientConfigKey<String>("RulePredicateClasses"){}; 158 159 public static final IClientConfigKey<String> RequestIdHeaderName = new CommonClientConfigKey<String>("RequestIdHeaderName") {}; 160 161 public static final IClientConfigKey<Boolean> UseIPAddrForServer = new CommonClientConfigKey<Boolean>("UseIPAddrForServer") {}; 162 163 public static final IClientConfigKey<String> ListOfServers = new CommonClientConfigKey<String>("listOfServers") {}; 164 165 private static final Set<IClientConfigKey> keys = new HashSet<IClientConfigKey>(); 166 167 // ... 168 }
View Code
進入到 DefaultClientConfigImpl,可以看到 CommonClientConfigKey 中的每個配置都對應了一個默認值。在載入配置的時候,如果用戶沒有訂製配置,就會使用默認的配置。


1 public class DefaultClientConfigImpl implements IClientConfig { 2 3 public static final Boolean DEFAULT_PRIORITIZE_VIP_ADDRESS_BASED_SERVERS = Boolean.TRUE; 4 5 public static final String DEFAULT_NFLOADBALANCER_PING_CLASSNAME = "com.netflix.loadbalancer.DummyPing"; // DummyPing.class.getName(); 6 7 public static final String DEFAULT_NFLOADBALANCER_RULE_CLASSNAME = "com.netflix.loadbalancer.AvailabilityFilteringRule"; 8 9 public static final String DEFAULT_NFLOADBALANCER_CLASSNAME = "com.netflix.loadbalancer.ZoneAwareLoadBalancer"; 10 11 public static final boolean DEFAULT_USEIPADDRESS_FOR_SERVER = Boolean.FALSE; 12 13 public static final String DEFAULT_CLIENT_CLASSNAME = "com.netflix.niws.client.http.RestClient"; 14 15 public static final String DEFAULT_VIPADDRESS_RESOLVER_CLASSNAME = "com.netflix.client.SimpleVipAddressResolver"; 16 17 public static final String DEFAULT_PRIME_CONNECTIONS_URI = "/"; 18 19 public static final int DEFAULT_MAX_TOTAL_TIME_TO_PRIME_CONNECTIONS = 30000; 20 21 public static final int DEFAULT_MAX_RETRIES_PER_SERVER_PRIME_CONNECTION = 9; 22 23 public static final Boolean DEFAULT_ENABLE_PRIME_CONNECTIONS = Boolean.FALSE; 24 25 public static final int DEFAULT_MAX_REQUESTS_ALLOWED_PER_WINDOW = Integer.MAX_VALUE; 26 27 public static final int DEFAULT_REQUEST_THROTTLING_WINDOW_IN_MILLIS = 60000; 28 29 public static final Boolean DEFAULT_ENABLE_REQUEST_THROTTLING = Boolean.FALSE; 30 31 public static final Boolean DEFAULT_ENABLE_GZIP_CONTENT_ENCODING_FILTER = Boolean.FALSE; 32 33 public static final Boolean DEFAULT_CONNECTION_POOL_CLEANER_TASK_ENABLED = Boolean.TRUE; 34 35 public static final Boolean DEFAULT_FOLLOW_REDIRECTS = Boolean.FALSE; 36 37 public static final float DEFAULT_PERCENTAGE_NIWS_EVENT_LOGGED = 0.0f; 38 39 public static final int DEFAULT_MAX_AUTO_RETRIES_NEXT_SERVER = 1; 40 41 public static final int DEFAULT_MAX_AUTO_RETRIES = 0; 42 43 public static final int DEFAULT_BACKOFF_INTERVAL = 0; 44 45 public static final int DEFAULT_READ_TIMEOUT = 5000; 46 47 public static final int DEFAULT_CONNECTION_MANAGER_TIMEOUT = 2000; 48 49 public static final int DEFAULT_CONNECT_TIMEOUT = 2000; 50 51 public static final Boolean DEFAULT_ENABLE_CONNECTION_POOL = Boolean.TRUE; 52 53 @Deprecated 54 public static final int DEFAULT_MAX_HTTP_CONNECTIONS_PER_HOST = 50; 55 56 @Deprecated 57 public static final int DEFAULT_MAX_TOTAL_HTTP_CONNECTIONS = 200; 58 59 public static final int DEFAULT_MAX_CONNECTIONS_PER_HOST = 50; 60 61 public static final int DEFAULT_MAX_TOTAL_CONNECTIONS = 200; 62 63 public static final float DEFAULT_MIN_PRIME_CONNECTIONS_RATIO = 1.0f; 64 65 public static final String DEFAULT_PRIME_CONNECTIONS_CLASS = "com.netflix.niws.client.http.HttpPrimeConnection"; 66 67 public static final String DEFAULT_SEVER_LIST_CLASS = "com.netflix.loadbalancer.ConfigurationBasedServerList"; 68 69 public static final String DEFAULT_SERVER_LIST_UPDATER_CLASS = "com.netflix.loadbalancer.PollingServerListUpdater"; 70 71 public static final int DEFAULT_CONNECTION_IDLE_TIMERTASK_REPEAT_IN_MSECS = 30000; // every half minute (30 secs) 72 73 public static final int DEFAULT_CONNECTIONIDLE_TIME_IN_MSECS = 30000; // all connections idle for 30 secs 74 75 protected volatile Map<String, Object> properties = new ConcurrentHashMap<String, Object>(); 76 77 protected Map<IClientConfigKey<?>, Object> typedProperties = new ConcurrentHashMap<IClientConfigKey<?>, Object>(); 78 79 private static final Logger LOG = LoggerFactory.getLogger(DefaultClientConfigImpl.class); 80 81 private String clientName = null; 82 83 private VipAddressResolver resolver = null; 84 85 private boolean enableDynamicProperties = true; 86 /** 87 * Defaults for the parameters for the thread pool used by batchParallel 88 * calls 89 */ 90 public static final int DEFAULT_POOL_MAX_THREADS = DEFAULT_MAX_TOTAL_HTTP_CONNECTIONS; 91 public static final int DEFAULT_POOL_MIN_THREADS = 1; 92 public static final long DEFAULT_POOL_KEEP_ALIVE_TIME = 15 * 60L; 93 public static final TimeUnit DEFAULT_POOL_KEEP_ALIVE_TIME_UNITS = TimeUnit.SECONDS; 94 public static final Boolean DEFAULT_ENABLE_ZONE_AFFINITY = Boolean.FALSE; 95 public static final Boolean DEFAULT_ENABLE_ZONE_EXCLUSIVITY = Boolean.FALSE; 96 public static final int DEFAULT_PORT = 7001; 97 public static final Boolean DEFAULT_ENABLE_LOADBALANCER = Boolean.TRUE; 98 99 public static final String DEFAULT_PROPERTY_NAME_SPACE = "ribbon"; 100 101 private String propertyNameSpace = DEFAULT_PROPERTY_NAME_SPACE; 102 103 public static final Boolean DEFAULT_OK_TO_RETRY_ON_ALL_OPERATIONS = Boolean.FALSE; 104 105 public static final Boolean DEFAULT_ENABLE_NIWS_EVENT_LOGGING = Boolean.TRUE; 106 107 public static final Boolean DEFAULT_IS_CLIENT_AUTH_REQUIRED = Boolean.FALSE; 108 109 private final Map<String, DynamicStringProperty> dynamicProperties = new ConcurrentHashMap<String, DynamicStringProperty>(); 110 111 public Boolean getDefaultPrioritizeVipAddressBasedServers() { 112 return DEFAULT_PRIORITIZE_VIP_ADDRESS_BASED_SERVERS; 113 } 114 115 public String getDefaultNfloadbalancerPingClassname() { 116 return DEFAULT_NFLOADBALANCER_PING_CLASSNAME; 117 } 118 119 public String getDefaultNfloadbalancerRuleClassname() { 120 return DEFAULT_NFLOADBALANCER_RULE_CLASSNAME; 121 } 122 123 public String getDefaultNfloadbalancerClassname() { 124 return DEFAULT_NFLOADBALANCER_CLASSNAME; 125 } 126 127 public boolean getDefaultUseIpAddressForServer() { 128 return DEFAULT_USEIPADDRESS_FOR_SERVER; 129 } 130 131 public String getDefaultClientClassname() { 132 return DEFAULT_CLIENT_CLASSNAME; 133 } 134 135 public String getDefaultVipaddressResolverClassname() { 136 return DEFAULT_VIPADDRESS_RESOLVER_CLASSNAME; 137 } 138 139 public String getDefaultPrimeConnectionsUri() { 140 return DEFAULT_PRIME_CONNECTIONS_URI; 141 } 142 143 public int getDefaultMaxTotalTimeToPrimeConnections() { 144 return DEFAULT_MAX_TOTAL_TIME_TO_PRIME_CONNECTIONS; 145 } 146 147 public int getDefaultMaxRetriesPerServerPrimeConnection() { 148 return DEFAULT_MAX_RETRIES_PER_SERVER_PRIME_CONNECTION; 149 } 150 151 public Boolean getDefaultEnablePrimeConnections() { 152 return DEFAULT_ENABLE_PRIME_CONNECTIONS; 153 } 154 155 public int getDefaultMaxRequestsAllowedPerWindow() { 156 return DEFAULT_MAX_REQUESTS_ALLOWED_PER_WINDOW; 157 } 158 159 public int getDefaultRequestThrottlingWindowInMillis() { 160 return DEFAULT_REQUEST_THROTTLING_WINDOW_IN_MILLIS; 161 } 162 163 public Boolean getDefaultEnableRequestThrottling() { 164 return DEFAULT_ENABLE_REQUEST_THROTTLING; 165 } 166 167 public Boolean getDefaultEnableGzipContentEncodingFilter() { 168 return DEFAULT_ENABLE_GZIP_CONTENT_ENCODING_FILTER; 169 } 170 171 public Boolean getDefaultConnectionPoolCleanerTaskEnabled() { 172 return DEFAULT_CONNECTION_POOL_CLEANER_TASK_ENABLED; 173 } 174 175 public Boolean getDefaultFollowRedirects() { 176 return DEFAULT_FOLLOW_REDIRECTS; 177 } 178 179 public float getDefaultPercentageNiwsEventLogged() { 180 return DEFAULT_PERCENTAGE_NIWS_EVENT_LOGGED; 181 } 182 183 public int getDefaultMaxAutoRetriesNextServer() { 184 return DEFAULT_MAX_AUTO_RETRIES_NEXT_SERVER; 185 } 186 187 public int getDefaultMaxAutoRetries() { 188 return DEFAULT_MAX_AUTO_RETRIES; 189 } 190 191 public int getDefaultReadTimeout() { 192 return DEFAULT_READ_TIMEOUT; 193 } 194 195 public int getDefaultConnectionManagerTimeout() { 196 return DEFAULT_CONNECTION_MANAGER_TIMEOUT; 197 } 198 199 public int getDefaultConnectTimeout() { 200 return DEFAULT_CONNECT_TIMEOUT; 201 } 202 203 @Deprecated 204 public int getDefaultMaxHttpConnectionsPerHost() { 205 return DEFAULT_MAX_HTTP_CONNECTIONS_PER_HOST; 206 } 207 208 @Deprecated 209 public int getDefaultMaxTotalHttpConnections() { 210 return DEFAULT_MAX_TOTAL_HTTP_CONNECTIONS; 211 } 212 213 public int getDefaultMaxConnectionsPerHost() { 214 return DEFAULT_MAX_CONNECTIONS_PER_HOST; 215 } 216 217 public int getDefaultMaxTotalConnections() { 218 return DEFAULT_MAX_TOTAL_CONNECTIONS; 219 } 220 221 public float getDefaultMinPrimeConnectionsRatio() { 222 return DEFAULT_MIN_PRIME_CONNECTIONS_RATIO; 223 } 224 225 public String getDefaultPrimeConnectionsClass() { 226 return DEFAULT_PRIME_CONNECTIONS_CLASS; 227 } 228 229 public String getDefaultSeverListClass() { 230 return DEFAULT_SEVER_LIST_CLASS; 231 } 232 233 public int getDefaultConnectionIdleTimertaskRepeatInMsecs() { 234 return DEFAULT_CONNECTION_IDLE_TIMERTASK_REPEAT_IN_MSECS; 235 } 236 237 public int getDefaultConnectionidleTimeInMsecs() { 238 return DEFAULT_CONNECTIONIDLE_TIME_IN_MSECS; 239 } 240 241 public VipAddressResolver getResolver() { 242 return resolver; 243 } 244 245 public boolean isEnableDynamicProperties() { 246 return enableDynamicProperties; 247 } 248 249 public int getDefaultPoolMaxThreads() { 250 return DEFAULT_POOL_MAX_THREADS; 251 } 252 253 public int getDefaultPoolMinThreads() { 254 return DEFAULT_POOL_MIN_THREADS; 255 } 256 257 public long getDefaultPoolKeepAliveTime() { 258 return DEFAULT_POOL_KEEP_ALIVE_TIME; 259 } 260 261 public TimeUnit getDefaultPoolKeepAliveTimeUnits() { 262 return DEFAULT_POOL_KEEP_ALIVE_TIME_UNITS; 263 } 264 265 public Boolean getDefaultEnableZoneAffinity() { 266 return DEFAULT_ENABLE_ZONE_AFFINITY; 267 } 268 269 public Boolean getDefaultEnableZoneExclusivity() { 270 return DEFAULT_ENABLE_ZONE_EXCLUSIVITY; 271 } 272 273 public int getDefaultPort() { 274 return DEFAULT_PORT; 275 } 276 277 public Boolean getDefaultEnableLoadbalancer() { 278 return DEFAULT_ENABLE_LOADBALANCER; 279 } 280 281 282 public Boolean getDefaultOkToRetryOnAllOperations() { 283 return DEFAULT_OK_TO_RETRY_ON_ALL_OPERATIONS; 284 } 285 286 public Boolean getDefaultIsClientAuthRequired(){ 287 return DEFAULT_IS_CLIENT_AUTH_REQUIRED; 288 } 289 290 291 /** 292 * Create instance with no properties in default name space {@link #DEFAULT_PROPERTY_NAME_SPACE} 293 */ 294 public DefaultClientConfigImpl() { 295 this.dynamicProperties.clear(); 296 this.enableDynamicProperties = false; 297 } 298 299 /** 300 * Create instance with no properties in the specified name space 301 */ 302 public DefaultClientConfigImpl(String nameSpace) { 303 this(); 304 this.propertyNameSpace = nameSpace; 305 } 306 307 public void loadDefaultValues() { 308 putDefaultIntegerProperty(CommonClientConfigKey.MaxHttpConnectionsPerHost, getDefaultMaxHttpConnectionsPerHost()); 309 putDefaultIntegerProperty(CommonClientConfigKey.MaxTotalHttpConnections, getDefaultMaxTotalHttpConnections()); 310 putDefaultBooleanProperty(CommonClientConfigKey.EnableConnectionPool, getDefaultEnableConnectionPool()); 311 putDefaultIntegerProperty(CommonClientConfigKey.MaxConnectionsPerHost, getDefaultMaxConnectionsPerHost()); 312 putDefaultIntegerProperty(CommonClientConfigKey.MaxTotalConnections, getDefaultMaxTotalConnections()); 313 putDefaultIntegerProperty(CommonClientConfigKey.ConnectTimeout, getDefaultConnectTimeout()); 314 putDefaultIntegerProperty(CommonClientConfigKey.ConnectionManagerTimeout, getDefaultConnectionManagerTimeout()); 315 putDefaultIntegerProperty(CommonClientConfigKey.ReadTimeout, getDefaultReadTimeout()); 316 putDefaultIntegerProperty(CommonClientConfigKey.MaxAutoRetries, getDefaultMaxAutoRetries()); 317 putDefaultIntegerProperty(CommonClientConfigKey.MaxAutoRetriesNextServer, getDefaultMaxAutoRetriesNextServer()); 318 putDefaultBooleanProperty(CommonClientConfigKey.OkToRetryOnAllOperations, getDefaultOkToRetryOnAllOperations()); 319 putDefaultBooleanProperty(CommonClientConfigKey.FollowRedirects, getDefaultFollowRedirects()); 320 putDefaultBooleanProperty(CommonClientConfigKey.ConnectionPoolCleanerTaskEnabled, getDefaultConnectionPoolCleanerTaskEnabled()); 321 putDefaultIntegerProperty(CommonClientConfigKey.ConnIdleEvictTimeMilliSeconds, getDefaultConnectionidleTimeInMsecs()); 322 putDefaultIntegerProperty(CommonClientConfigKey.ConnectionCleanerRepeatInterval, getDefaultConnectionIdleTimertaskRepeatInMsecs()); 323 putDefaultBooleanProperty(CommonClientConfigKey.EnableGZIPContentEncodingFilter, getDefaultEnableGzipContentEncodingFilter()); 324 String proxyHost = ConfigurationManager.getConfigInstance().getString(getDefaultPropName(CommonClientConfigKey.ProxyHost.key())); 325 if (proxyHost != null && proxyHost.length() > 0) { 326 setProperty(CommonClientConfigKey.ProxyHost, proxyHost); 327 } 328 Integer proxyPort = ConfigurationManager 329 .getConfigInstance() 330 .getInteger( 331 getDefaultPropName(CommonClientConfigKey.ProxyPort), 332 (Integer.MIN_VALUE + 1)); // + 1 just to avoid potential clash with user setting 333 if (proxyPort != (Integer.MIN_VALUE + 1)) { 334 setProperty(CommonClientConfigKey.ProxyPort, proxyPort); 335 } 336 putDefaultIntegerProperty(CommonClientConfigKey.Port, getDefaultPort()); 337 putDefaultBooleanProperty(CommonClientConfigKey.EnablePrimeConnections, getDefaultEnablePrimeConnections()); 338 putDefaultIntegerProperty(CommonClientConfigKey.MaxRetriesPerServerPrimeConnection, getDefaultMaxRetriesPerServerPrimeConnection()); 339 putDefaultIntegerProperty(CommonClientConfigKey.MaxTotalTimeToPrimeConnections, getDefaultMaxTotalTimeToPrimeConnections()); 340 putDefaultStringProperty(CommonClientConfigKey.PrimeConnectionsURI, getDefaultPrimeConnectionsUri()); 341 putDefaultIntegerProperty(CommonClientConfigKey.PoolMinThreads, getDefaultPoolMinThreads()); 342 putDefaultIntegerProperty(CommonClientConfigKey.PoolMaxThreads, getDefaultPoolMaxThreads()); 343 putDefaultLongProperty(CommonClientConfigKey.PoolKeepAliveTime, getDefaultPoolKeepAliveTime()); 344 putDefaultTimeUnitProperty(CommonClientConfigKey.PoolKeepAliveTimeUnits, getDefaultPoolKeepAliveTimeUnits()); 345 putDefaultBooleanProperty(CommonClientConfigKey.EnableZoneAffinity, getDefaultEnableZoneAffinity()); 346 putDefaultBooleanProperty(CommonClientConfigKey.EnableZoneExclusivity, getDefaultEnableZoneExclusivity()); 347 putDefaultStringProperty(CommonClientConfigKey.ClientClassName, getDefaultClientClassname()); 348 putDefaultStringProperty(CommonClientConfigKey.NFLoadBalancerClassName, getDefaultNfloadbalancerClassname()); 349 putDefaultStringProperty(CommonClientConfigKey.NFLoadBalancerRuleClassName, getDefaultNfloadbalancerRuleClassname()); 350 putDefaultStringProperty(CommonClientConfigKey.NFLoadBalancerPingClassName, getDefaultNfloadbalancerPingClassname()); 351 putDefaultBooleanProperty(CommonClientConfigKey.PrioritizeVipAddressBasedServers, getDefaultPrioritizeVipAddressBasedServers()); 352 putDefaultFloatProperty(CommonClientConfigKey.MinPrimeConnectionsRatio, getDefaultMinPrimeConnectionsRatio()); 353 putDefaultStringProperty(CommonClientConfigKey.PrimeConnectionsClassName, getDefaultPrimeConnectionsClass()); 354 putDefaultStringProperty(CommonClientConfigKey.NIWSServerListClassName, getDefaultSeverListClass()); 355 putDefaultStringProperty(CommonClientConfigKey.VipAddressResolverClassName, getDefaultVipaddressResolverClassname()); 356 putDefaultBooleanProperty(CommonClientConfigKey.IsClientAuthRequired, getDefaultIsClientAuthRequired()); 357 // putDefaultStringProperty(CommonClientConfigKey.RequestIdHeaderName, getDefaultRequestIdHeaderName()); 358 putDefaultBooleanProperty(CommonClientConfigKey.UseIPAddrForServer, getDefaultUseIpAddressForServer()); 359 putDefaultStringProperty(CommonClientConfigKey.ListOfServers, ""); 360 } 361 }
View Code
也可以在配置文件中訂製配置,例如配置超時和重試:
1 # 全局配置 2 ribbon: 3 # 客戶端讀取超時時間 4 ReadTimeout: 3000 5 # 客戶端連接超時時間 6 ConnectTimeout: 3000 7 # 默認只重試 GET,設置為 true 時將重試所有類型,如 POST、PUT、DELETE 8 OkToRetryOnAllOperations: false 9 # 重試次數 10 MaxAutoRetries: 1 11 # 最多重試幾個實例 12 MaxAutoRetriesNextServer: 1 13 14 # 只針對 demo-producer 客戶端 15 demo-producer: 16 ribbon: 17 # 客戶端讀取超時時間 18 ReadTimeout: 5000 19 # 客戶端連接超時時間 20 ConnectTimeout: 3000
2、均衡策略 — IRule
IRule 是最終選擇 Server 的策略規則類,核心的介面就是 choose。
1 public interface IRule{ 2 3 // 選擇 Server 4 public Server choose(Object key); 5 6 // 設置 ILoadBalancer 7 public void setLoadBalancer(ILoadBalancer lb); 8 9 // 獲取 ILoadBalancer 10 public ILoadBalancer getLoadBalancer(); 11 }
Ribbon 提供了豐富的負載均衡策略,我們也可以通過配置指定使用某個均衡策略。下面是整個Ribbon提供的 IRule 均衡策略。
3、服務檢查 — IPing
IPing 是用於定期檢查 Server 的可用性的,它只提供了一個介面,用來判斷 Server 是否存活:
1 public interface IPing {
2
3 public boolean isAlive(Server server);
4 }
IPing 也提供了多種策略可選,下面是整個 IPing 體系結構:
4、獲取服務列表 — ServerList
ServerList 提供了兩個介面,一個是第一次獲取 Server 列表,一個是更新 Server 列表,其中 getUpdatedListOfServers 會每被 Loadbalancer 隔 30 秒調一次來更新 allServerList。
1 public interface ServerList<T extends Server> {
2
3 public List<T> getInitialListOfServers();
4
5 /**
6 * Return updated list of servers. This is called say every 30 secs
7 * (configurable) by the Loadbalancer's Ping cycle
8 */
9 public List<T> getUpdatedListOfServers();
10 }
ServerList 也提供了多種實現,ServerList 體系結構如下:
5、過濾服務 — ServerListFilter
ServerListFilter 提供了一個介面用來過濾出可用的 Server。
1 public interface ServerListFilter<T extends Server> { 2 3 public List<T> getFilteredListOfServers(List<T> servers); 4 }
ServerListFilter 體系結構如下:
6、服務列表更新 — ServerListUpdater
ServerListUpdater 有多個介面,最核心的就是 start 開啟定時任務調用 updateAction 來更新 allServerList。
1 public interface ServerListUpdater {
2
3 /**
4 * an interface for the updateAction that actually executes a server list update
5 */
6 public interface UpdateAction {
7 void doUpdate();
8 }
9
10 /**
11 * start the serverList updater with the given update action
12 * This call should be idempotent.
13 */
14 void start(UpdateAction updateAction);
15 }
默認有兩個實現類:
7、負載均衡器 — ILoadBalancer
ILoadBalancer 是負載均衡選擇服務的核心介面,主要提供了如下的獲取Server列表和根據客戶端名稱選擇Server的介面。
1 public interface ILoadBalancer {
2
3 // 添加Server
4 public void addServers(List<Server> newServers);
5
6 // 根據key選擇一個Server
7 public Server chooseServer(Object key);
8
9 // 獲取存活的Server列表,返回 upServerList
10 public List<Server> getReachableServers();
11
12 // 獲取所有Server列表,返回 allServerList
13 public List<Server> getAllServers();
14 }
ILoadBalancer 的體系結構如下:
8、Ribbon 相關配置類
從前面一直看下來,可以發現有很多與 Ribbon 相關的配置類,這裡總結下與 Ribbon 相關的配置類,看每個配置類的配置順序,以及都主要配置了哪些東西。
① 首先是Eureka客戶端配置類 EurekaClientAutoConfiguration,這個自動化配置類主要配置了 Ribbon 所需的 EurekaClient。


1 @Configuration(proxyBeanMethods = false) 2 @EnableConfigurationProperties 3 @ConditionalOnClass(EurekaClientConfig.class) 4 @ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true) 5 @ConditionalOnDiscoveryEnabled 6 @AutoConfigureBefore({ NoopDiscoveryClientAutoConfiguration.class, 7 CommonsClientAutoConfiguration.class, ServiceRegistryAutoConfiguration.class }) 8 @AutoConfigureAfter(name = { 9 "org.springframework.cloud.netflix.eureka.config.DiscoveryClientOptionalArgsConfiguration", 10 "org.springframework.cloud.autoconfigure.RefreshAutoConfiguration", 11 "org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration", 12 "org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration" }) 13 public class EurekaClientAutoConfiguration { 14 // .... 15 }
View Code
② 接著是Ribbon自動化配置類 RibbonAutoConfiguration,這個類主要配置了如下類:
- SpringClientFactory:管理 Ribbon 客戶端上下文。
- LoadBalancerClient:負載均衡客戶端,默認實現類為 RibbonLoadBalancerClient(實際是在 RibbonClientConfiguration 中配置的)。
- PropertiesFactory:用於判斷配置文件中是否自定義了核心介面的實現類,如 NFLoadBalancerClassName、NFLoadBalancerPingClassName 等。
- RibbonApplicationContextInitializer:開啟飢餓配置的時候,用這個類來在啟動時初始化 Ribbon 客戶端上下文。


1 package org.springframework.cloud.netflix.ribbon; 2 3 @Configuration 4 @Conditional(RibbonAutoConfiguration.RibbonClassesConditions.class) 5 @RibbonClients 6 // 在 EurekaClientAutoConfiguration 之後配置 7 @AutoConfigureAfter(name = "org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration") 8 // 在 LoadBalancerAutoConfiguration、AsyncLoadBalancerAutoConfiguration 之前配置 9 @AutoConfigureBefore({ LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class }) 10 @EnableConfigurationProperties({ RibbonEagerLoadProperties.class, ServerIntrospectorProperties.class }) 11 public class RibbonAutoConfiguration { 12 13 @Autowired(required = false) 14 private List<RibbonClientSpecification> configurations = new ArrayList<>(); 15 16 @Autowired 17 private RibbonEagerLoadProperties ribbonEagerLoadProperties; 18 19 @Bean 20 public HasFeatures ribbonFeature() { 21 return HasFeatures.namedFeature("Ribbon", Ribbon.class); 22 } 23 24 @Bean 25 @ConditionalOnMissingBean 26 public SpringClientFactory springClientFactory() { 27 SpringClientFactory factory = new SpringClientFactory(); 28 factory.setConfigurations(this.configurations); 29 return factory; 30 } 31 32 @Bean 33 @ConditionalOnMissingBean(LoadBalancerClient.class) 34 public LoadBalancerClient loadBalancerClient() { 35 return new RibbonLoadBalancerClient(springClientFactory()); 36 } 37 38 @Bean 39 @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") 40 @ConditionalOnMissingBean 41 public LoadBalancedRetryFactory loadBalancedRetryPolicyFactory(final SpringClientFactory clientFactory) { 42 return new RibbonLoadBalancedRetryFactory(clientFactory); 43 } 44 45 @Bean 46 @ConditionalOnMissingBean 47 public PropertiesFactory propertiesFactory() { 48 return new PropertiesFactory(); 49 } 50 51 @Bean 52 @ConditionalOnProperty("ribbon.eager-load.enabled") 53 public RibbonApplicationContextInitializer ribbonApplicationContextInitializer() { 54 return new RibbonApplicationContextInitializer(springClientFactory(), ribbonEagerLoadProperties.getClients()); 55 } 56 }
View Code
③ 接著是負載均衡器配置類 LoadBalancerAutoConfiguration,這個類主要是創建了負載均衡攔截器 LoadBalancerInterceptor,並添加到 RestTemplae 的攔截器中。


1 package org.springframework.cloud.client.loadbalancer; 2 3 @Configuration(proxyBeanMethods = false) 4 @ConditionalOnClass(RestTemplate.class) 5 @ConditionalOnBean(LoadBalancerClient.class) 6 @EnableConfigurationProperties(LoadBalancerRetryProperties.class) 7 public class LoadBalancerAutoConfiguration { 8 9 @LoadBalanced 10 @Autowired(required = false) 11 private List<RestTemplate> restTemplates = Collections.emptyList(); 12 13 @Autowired(required = false) 14 private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList(); 15 16 // 對 RestTemplate 訂製化 17 @Bean 18 public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated( 19 final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) { 20 return () -> restTemplateCustomizers.ifAvailable(customizers -> { 21 for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) { 22 for (RestTemplateCustomizer customizer : customizers) { 23 customizer.customize(restTemplate); 24 } 25 } 26 }); 27 } 28 29 @Bean 30 @ConditionalOnMissingBean 31 public LoadBalancerRequestFactory loadBalancerRequestFactory(LoadBalancerClient loadBalancerClient) { 32 return new LoadBalancerRequestFactory(loadBalancerClient, this.transformers); 33 } 34 35 @Configuration(proxyBeanMethods = false) 36 @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate") 37 static class LoadBalancerInterceptorConfig { 38 39 // 創建 RestTemplate 攔截器 40 @Bean 41 public LoadBalancerInterceptor ribbonInterceptor(LoadBalancerClient loadBalancerClient, 42 LoadBalancerRequestFactory requestFactory) { 43 return new LoadBalancerInterceptor(loadBalancerClient, requestFactory); 44 } 45 46 @Bean 47 @ConditionalOnMissingBean 48 public RestTemplateCustomizer restTemplateCustomizer(final LoadBalancerInterceptor loadBalancerInterceptor) { 49 return restTemplate -> { 50 List<ClientHttpRequestInterceptor> list = new ArrayList<>( 51 restTemplate.getInterceptors()); 52 list.add(loadBalancerInterceptor); 53 restTemplate.setInterceptors(list); 54 }; 55 } 56 57 } 58 }
View Code
④ 之後是默認的 Ribbon 客戶端配置類 RibbonClientConfiguration,這個類主要配置了 Ribbon 核心介面的默認實現。
- IClientConfig:Ribbon 客戶端配置類,默認實現是 DefaultClientConfigImpl。
- IRule:負載均衡策略規則組件,默認實現是 ZoneAvoidanceRule。
- IPing:判斷 Server 是否存活,默認實現是 DummyPing,永遠都是返回 true。
- ServerList:獲取 Server 的組件,默認實現類為 ConfigurationBasedServerList,從配置文件獲取。
- ServerListUpdater:Server 列表更新組件,默認實現類為 PollingServerListUpdater。
- ServerListFilter:過濾可用的 Server 列表,默認實現類為 ZonePreferenceServerListFilter。
- RibbonLoadBalancerContext:負載均衡客戶端。
- RetryHandler:重試處理器,默認實現類為 DefaultLoadBalancerRetryHandler。


1 package org.springframework.cloud.netflix.ribbon; 2 3 @SuppressWarnings("deprecation") 4 @Configuration(proxyBeanMethods = false) 5 @EnableConfigurationProperties 6 @Import({ HttpClientConfiguration.class, OkHttpRibbonConfiguration.class, 7 RestClientRibbonConfiguration.class, HttpClientRibbonConfiguration.class }) 8 public class RibbonClientConfiguration { 9 public static final int DEFAULT_CONNECT_TIMEOUT = 1000; 10 public static final int DEFAULT_READ_TIMEOUT = 1000; 11 public static final boolean DEFAULT_GZIP_PAYLOAD = true; 12 13 @RibbonClientName 14 private String name = "client"; 15 16 @Autowired 17 private PropertiesFactory propertiesFactory; 18 19 @Bean 20 @ConditionalOnMissingBean 21 public IClientConfig ribbonClientConfig() { 22 DefaultClientConfigImpl config = new DefaultClientConfigImpl(); 23 config.loadProperties(this.name); 24 config.set(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT); 25 config.set(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT); 26 config.set(CommonClientConfigKey.GZipPayload, DEFAULT_GZIP_PAYLOAD); 27 return config; 28 } 29 30 @Bean 31 @ConditionalOnMissingBean 32 public IRule ribbonRule(IClientConfig config) { 33 if (this.propertiesFactory.isSet(IRule.class, name)) { 34 return this.propertiesFactory.get(IRule.class, config, name); 35 } 36 ZoneAvoidanceRule rule = new ZoneAvoidanceRule(); 37 rule.initWithNiwsConfig(config); 38 return rule; 39 } 40 41 @Bean 42 @ConditionalOnMissingBean 43 public IPing ribbonPing(IClientConfig config) { 44 if (this.propertiesFactory.isSet(IPing.class, name)) { 45 return this.propertiesFactory.get(IPing.class, config, name); 46 } 47 return new DummyPing(); 48 } 49 50 @Bean 51 @ConditionalOnMissingBean 52 @SuppressWarnings("unchecked") 53 public ServerList<Server> ribbonServerList(IClientConfig config) { 54 if (this.propertiesFactory.isSet(ServerList.class, name)) { 55 return this.propertiesFactory.get(ServerList.class, config, name); 56 } 57 ConfigurationBasedServerList serverList = new ConfigurationBasedServerList(); 58 serverList.initWithNiwsConfig(config); 59 return serverList; 60 } 61 62 @Bean 63 @ConditionalOnMissingBean 64 public ServerListUpdater ribbonServerListUpdater(IClientConfig config) { 65 return new PollingServerListUpdater(config); 66 } 67 68 @Bean 69 @ConditionalOnMissingBean 70 public ILoadBalancer ribbonLoadBalancer(IClientConfig config, 71 ServerList<Server> serverList, ServerListFilter<Server> serverListFilter, 72 IRule rule, IPing ping, ServerListUpdater serverListUpdater) { 73 if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) { 74 return this.propertiesFactory.get(ILoadBalancer.class, config, name); 75 } 76 return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList, 77 serverListFilter, serverListUpdater); 78 } 79 80 @Bean 81 @ConditionalOnMissingBean 82 @SuppressWarnings("unchecked") 83 public ServerListFilter<Server> ribbonServerListFilter(IClientConfig config) { 84 if (this.propertiesFactory.isSet(ServerListFilter.class, name)) { 85 return this.propertiesFactory.get(ServerListFilter.class, config, name); 86 } 87 ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter(); 88 filter.initWithNiwsConfig(config); 89 return filter; 90 } 91 92 @Bean 93 @ConditionalOnMissingBean 94 public RibbonLoadBalancerContext ribbonLoadBalancerContext(ILoadBalancer loadBalancer, 95 IClientConfig config, RetryHandler retryHandler) { 96 return new RibbonLoadBalancerContext(loadBalancer, config, retryHandler); 97 } 98 99 @Bean 100 @ConditionalOnMissingBean 101 public RetryHandler retryHandler(IClientConfig config) { 102 return new DefaultLoadBalancerRetryHandler(config); 103 } 104 105 @Bean 106 @ConditionalOnMissingBean 107 public ServerIntrospector serverIntrospector() { 108 return new DefaultServerIntrospector(); 109 } 110 }
View Code
⑤ Ribbon Eureka 自動化配置類 RibbonEurekaAutoConfiguration,判斷是否啟用 Ribbon Eureka,並觸發 EurekaRibbonClientConfiguration 配置類。


1 package org.springframework.cloud.netflix.ribbon.eureka; 2 3 @Configuration(proxyBeanMethods = false) 4 @EnableConfigurationProperties 5 @ConditionalOnRibbonAndEurekaEnabled 6 @AutoConfigureAfter(RibbonAutoConfiguration.class) 7 @RibbonClients(defaultConfiguration = EurekaRibbonClientConfiguration.class) 8 public class RibbonEurekaAutoConfiguration { 9 10 }
View Code
⑥ 默認啟用 Ribbon Eureka 的情況下,會使用 Ribbon Eureka 客戶端配置類 EurekaRibbonClientConfiguration:
- IPing:替換了默認實現類 DummyPing,改為 NIWSDiscoveryPing,通過判斷 InstanceInfo 的狀態是否為 UP 來判斷 Server 是否存活。
- ServerList:替換了默認的實現類 ConfigurationBasedServerList,改為 DomainExtractingServerList,實際是 DiscoveryEnabledNIWSServerList,從 EurekaClient 獲取 Server 列表。


1 package org.springframework.cloud.netflix.ribbon.eureka; 2 3 @Configuration(proxyBeanMethods = false) 4 public class EurekaRibbonClientConfiguration { 5 6 private static final Log log = LogFactory.getLog(EurekaRibbonClientConfiguration.class); 7 8 @Value("${ribbon.eureka.approximateZoneFromHostname:false}") 9 private boolean approximateZoneFromHostname = false; 10 @RibbonClientName 11 private String serviceId = "client"; 12 @Autowired(required = false) 13 private EurekaClientConfig clientConfig; 14 @Autowired(required = false) 15 private EurekaInstanceConfig eurekaConfig; 16 @Autowired 17 private PropertiesFactory propertiesFactory; 18 19 public EurekaRibbonClientConfiguration() { 20 } 21 22 public EurekaRibbonClientConfiguration(EurekaClientConfig clientConfig, 23 String serviceId, EurekaInstanceConfig eurekaConfig, 24 boolean approximateZoneFromHostname) { 25 this.clientConfig = clientConfig; 26 this.serviceId = serviceId; 27 this.eurekaConfig = eurekaConfig; 28 this.approximateZoneFromHostname = approximateZoneFromHostname; 29 } 30 31 @Bean 32 @ConditionalOnMissingBean 33 public IPing ribbonPing(IClientConfig config) { 34 if (this.propertiesFactory.isSet(IPing.class, serviceId)) { 35 return this.propertiesFactory.get(IPing.class, config, serviceId); 36 } 37 NIWSDiscoveryPing ping = new NIWSDiscoveryPing(); 38 ping.initWithNiwsConfig(config); 39 return ping; 40 } 41 42 @Bean 43 @ConditionalOnMissingBean 44 public ServerList<?> ribbonServerList(IClientConfig config, Provider<EurekaClient> eurekaClientProvider) { 45 if (this.propertiesFactory.isSet(ServerList.class, serviceId)) { 46 return this.propertiesFactory.get(ServerList.class, config, serviceId); 47 } 48 DiscoveryEnabledNIWSServerList discoveryServerList = new DiscoveryEnabledNIWSServerList( 49 config, eurekaClientProvider); 50 DomainExtractingServerList serverList = new DomainExtractingServerList( 51 discoveryServerList, config, this.approximateZoneFromHostname); 52 return serverList; 53 } 54 }
View Code
⑦ 各個配置類所屬模組
spring-cloud-netflix-eureka-client:
- org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration
- org.springframework.cloud.netflix.ribbon.eureka.RibbonEurekaAutoConfiguration
- org.springframework.cloud.netflix.ribbon.eureka.EurekaRibbonClientConfiguration
spring-cloud-netflix-ribbon:
- org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration
- org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration
spring-cloud-commons:
- org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration
六、Ribbon HTTP客戶端組件
1、Java HTTP 組件庫
① HTTP 組件庫
首先簡單了解下常用的 Java HTTP 組件庫,Ribbon 中通過不同的配置便可以啟用某個 HTTP 組件來進行服務間的通訊。
Java 中的 HTTP 組件庫,大體可以分為三類:
- JDK 自帶的標準庫 HttpURLConnection
- Apache HttpComponents HttpClient
- OkHttp
HttpURLConnection 發起 HTTP 請求最大的優點是不需要引入額外的依賴,但是 HttpURLConnection 封裝層次太低,使用起來非常繁瑣。支援的特性太少,缺乏連接池管理、域名機械控制,無法支援 HTTP/2等。
Apache HttpComponents HttpClient 和 OkHttp 都支援連接池管理、超時、空閑連接數控制等特性。OkHttp 介面設計更友好,且支援 HTTP/2,Android 開發中用得更多。
② 超時重試配置
先給 demo-consumer 中添加如下默認配置,即讀取、連接超時時間設置為 1 秒,這也是默認值。然後重試次數為1,重試一個Server。後面基於這些配置來驗證Ribbon HTTP客戶端的超時和重試。
1 ribbon: 2 # 客戶端讀取超時時間 3 ReadTimeout: 1000 4 # 客戶端連接超時時間 5 ConnectTimeout: 1000 6 # 默認只重試 GET,設置為 true 時將重試所有類型,如 POST、PUT、DELETE 7 OkToRetryOnAllOperations: false 8 # 重試次數 9 MaxAutoRetries: 1 10 # 最多重試幾個實例 11 MaxAutoRetriesNextServer: 1
然後 demo-producer 的介面休眠3秒,造成網路延遲的現象,並且 demo-producer 啟兩個實例。
1 @GetMapping("/v1/uuid") 2 public ResponseEntity<String> getUUID() throws InterruptedException { 3 String uuid = UUID.randomUUID().toString(); 4 logger.info("generate uuid: {}", uuid); 5 Thread.sleep(3000); 6 return ResponseEntity.ok(uuid); 7 }
2、Ribbon 默認使用 HttpURLConnection
① Ribbon 默認的 HTTP 組件
在不添加其它配置的情況下,我們來看下 Ribbon 默認使用的 HTTP 組件是什麼。
首先通過之前的分析可以知道,默認情況下,LoadBalancerAutoConfiguration 配置類會向 RestTemplate 添加 LoadBalancerInterceptor 攔截器。然後在 RestTemplate 調用時,即在 doExecute 方法中,創建 ClientHttpRequest 時,因為配置了攔截器,所以 ClientHttpRequestFactory 就是 InterceptingClientHttpRequestFactory,而且創建 InterceptingClientHttpRequestFactory 傳入的 ClientHttpRequestFactory 默認是父類的 SimpleClientHttpRequestFactory。


1 protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback, 2 @Nullable ResponseExtractor<T> responseExtractor) throws RestClientException { 3 //... 4 ClientHttpResponse response = null; 5 try { 6 // 創建 ClientHttpRequest 7 ClientHttpRequest request = createRequest(url, method); 8 if (requestCallback != null) { 9 requestCallback.doWithRequest(request); 10 } 11 // ClientHttpRequest 發起請求 12 response = request.execute(); 13 handleResponse(url, method, response); 14 return (responseExtractor != null ? responseExtractor.extractData(response) : null); 15 } 16 catch (IOException ex) { 17 // ... 18 } 19 finally { 20 if (response != null) { 21 response.close(); 22 } 23 } 24 } 25 26 protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException { 27 // getRequestFactory 獲取 ClientHttpRequestFactory 28 ClientHttpRequest request = getRequestFactory().createRequest(url, method); 29 initialize(request); 30 if (logger.isDebugEnabled()) { 31 logger.debug("HTTP " + method.name() + " " + url); 32 } 33 return request; 34 } 35 36 public ClientHttpRequestFactory getRequestFactory() { 37 List<ClientHttpRequestInterceptor> interceptors = getInterceptors(); 38 if (!CollectionUtils.isEmpty(interceptors)) { 39 ClientHttpRequestFactory factory = this.interceptingRequestFactory; 40 if (factory == null) { 41 // 有攔截器的情況,super.getRequestFactory() 默認返回的是 SimpleClientHttpRequestFactory 42 factory = new InterceptingClientHttpRequestFactory(super.getRequestFactory(), interceptors); 43 this.interceptingRequestFactory = factory; 44 } 45 return factory; 46 } 47 else { 48 // 無攔截器的情況 49 return super.getRequestFactory(); 50 } 51 }
View Code
InterceptingClientHttpRequestFactory 這個工廠類創建的 ClientHttpRequest 類型是 InterceptingClientHttpRequest。最終 RestTemplate 的 doExecute 方法中調用 ClientHttpRequest 的 execute 方法時,就調用到了 InterceptingClientHttpRequest 中的內部類 InterceptingRequestExecution 中。
在 InterceptingRequestExecution 的 execute 方法中,首先是遍歷所有攔截器對 RestTemplate 訂製化,最後則通過 requestFactory 創建 ClientHttpRequest 來發起最終的 HTTP 調用。從這裡可以看出,無論有沒有攔截器,其實最終都會使用 requestFactory 來創建 ClientHttpRequest。
1 private class InterceptingRequestExecution implements ClientHttpRequestExecution { 2 private final Iterator<ClientHttpRequestInterceptor> iterator; 3 4 @Override 5 public ClientHttpResponse execute(HttpRequest request, byte[] body) throws IOException { 6 if (this.iterator.hasNext()) { 7 // 攔截器訂製化 RestTemplate 8 ClientHttpRequestInterceptor nextInterceptor = this.iterator.next(); 9 return nextInterceptor.intercept(request, body, this); 10 } 11 else { 12 HttpMethod method = request.getMethod(); 13 // delegate => SimpleBufferingClientHttpRequest 14 ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), method); 15 //... 16 return delegate.execute(); 17 } 18 } 19 }
這裡的 requestFactory 就是前面傳進來的 SimpleClientHttpRequestFactory,從它的 createRequest 方法可以看出,默認情況下,就是用的 JDK 標準 HTTP 庫組件 HttpURLConnection 來進行服務間的請求通訊。
1 public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException { 2 // JDK 標準HTTP庫 HttpURLConnection 3 HttpURLConnection connection = openConnection(uri.toURL(), this.proxy); 4 prepareConnection(connection, httpMethod.name()); 5 6 if (this.bufferRequestBody) { 7 return new SimpleBufferingClientHttpRequest(connection, this.outputStreaming); 8 } 9 else { 10 return new SimpleStreamingClientHttpRequest(connection, this.chunkSize, this.outputStreaming); 11 } 12 }
總結:
從前面的源碼分析可以看出,Ribbon 默認的 HTTP 客戶端是 HttpURLConnection。
在前面默認的超時配置下,可以驗證出超時配置並未生效,一直阻塞3秒後才返回了結果,說明 Ribbon 默認情況下就不支援超時重試。
而且 HttpURLConnection 每次都是新創建的,請求返回來之後就關閉連接,沒有連接池管理機制,網路連接的建立和關閉本身就會損耗一定的性能,所以正式環境下,最好不要使用默認的配置。
② HttpClient 配置類
另外,我們從 RibbonClientConfiguration 配置類的定義可以看到,其導入了 HttpClientConfiguration、OkHttpRibbonConfiguration、RestClientRibbonConfiguration、HttpClientRibbonConfiguration 四個 HttpClient 的配置類,通過注釋也可以了解到,最後一個是默認配置類,前面三個在某些配置啟用的情況下才會生效。
1 @Configuration(proxyBeanMethods = false) 2 @EnableConfigurationProperties 3 // Order is important here, last should be the default, first should be optional 4 @Import({ HttpClientConfiguration.class, OkHttpRibbonConfiguration.class, 5 RestClientRibbonConfiguration.class, HttpClientRibbonConfiguration.class }) 6 public class RibbonClientConfiguration { 7 8 }
進入 HttpClientRibbonConfiguration,這個配置類在 ribbon.httpclient.enabled=true 時才生效,而且默認為 true。在從 SpringClientFactory 中獲取 ILoadBalancer 時,會通過這個配置類初始化 HttpClient,按先後順序會初始化 HttpClientConnectionManager、CloseableHttpClient、RibbonLoadBalancingHttpClient。CloseableHttpClient 是 Apache HttpComponents HttpClient 中的組件,也就是說默認情況下應該是使用 apache HttpComponents 作為 HTTP 組件庫。
但經過前面源碼的分析,以及測試發現,最終其實走的的 HttpURLConnection,並沒有用到 CloseableHttpClient。把 ribbon.httpclient.enabled 設置為 false,也沒有什麼影響,還是默認走 HttpURLConnection。我們後面再來分析這個問題。


1 @Configuration(proxyBeanMethods = false) 2 @ConditionalOnClass(name = "org.apache.http.client.HttpClient") 3 // ribbon.httpclient.enabled more文為 true 4 @ConditionalOnProperty(name = "ribbon.httpclient.enabled", matchIfMissing = true) 5 public class HttpClientRibbonConfiguration { 6 7 @RibbonClientName 8 private String name = "client"; 9 10 // RibbonLoadBalancingHttpClient 11 @Bean 12 @ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class) 13 @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate") 14 public RibbonLoadBalancingHttpClient ribbonLoadBalancingHttpClient( 15 IClientConfig config, ServerIntrospector serverIntrospector, 16 ILoadBalancer loadBalancer, RetryHandler retryHandler, 17 CloseableHttpClient httpClient) { 18 RibbonLoadBalancingHttpClient client = new RibbonLoadBalancingHttpClient( 19 httpClient, config, serverIntrospector); 20 client.setLoadBalancer(loadBalancer); 21 client.setRetryHandler(retryHandler); 22 Monitors.registerObject("Client_" + this.name, client); 23 return client; 24 } 25 26 // 在引入了 spring-retry 時,即可以重試的 RetryTemplate 時,就創建 RetryableRibbonLoadBalancingHttpClient 27 @Bean 28 @ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class) 29 @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") 30 public RetryableRibbonLoadBalancingHttpClient retryableRibbonLoadBalancingHttpClient( 31 IClientConfig config, ServerIntrospector serverIntrospector, 32 ILoadBalancer loadBalancer, RetryHandler retryHandler, 33 LoadBalancedRetryFactory loadBalancedRetryFactory, 34 CloseableHttpClient httpClient, 35 RibbonLoadBalancerContext ribbonLoadBalancerContext) { 36 RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient( 37 httpClient, config, serverIntrospector, loadBalancedRetryFactory); 38 client.setLoadBalancer(loadBalancer); 39 client.setRetryHandler(retryHandler); 40 client.setRibbonLoadBalancerContext(ribbonLoadBalancerContext); 41 Monitors.registerObject("Client_" + this.name, client); 42 return client; 43 } 44 45 @Configuration(proxyBeanMethods = false) 46 protected static class ApacheHttpClientConfiguration { 47 48 private final Timer connectionManagerTimer = new Timer( 49 "RibbonApacheHttpClientConfiguration.connectionManagerTimer", true); 50 51 private CloseableHttpClient httpClient; 52 53 @Autowired(required = false) 54 private RegistryBuilder registryBuilder; 55 56 // HttpClient 連接池管理器 57 @Bean 58 @ConditionalOnMissingBean(HttpClientConnectionManager.class) 59 public HttpClientConnectionManager httpClientConnectionManager( 60 IClientConfig config, 61 ApacheHttpClientConnectionManagerFactory connectionManagerFactory) { 62 RibbonProperties ribbon = RibbonProperties.from(config); 63 int maxTotalConnections = ribbon.maxTotalConnections(); 64 int maxConnectionsPerHost = ribbon.maxConnectionsPerHost(); 65 int timerRepeat = ribbon.connectionCleanerRepeatInterval(); 66 long timeToLive = ribbon.poolKeepAliveTime(); 67 TimeUnit ttlUnit = ribbon.getPoolKeepAliveTimeUnits(); 68 final HttpClientConnectionManager connectionManager = connectionManagerFactory 69 .newConnectionManager(false, maxTotalConnections, 70 maxConnectionsPerHost, timeToLive, ttlUnit, registryBuilder); 71 this.connectionManagerTimer.schedule(new TimerTask() { 72 @Override 73 public void run() { 74 connectionManager.closeExpiredConnections(); 75 } 76 }, 30000, timerRepeat); 77 return connectionManager; 78 } 79 80 // HttpClient => CloseableHttpClient 81 @Bean 82 @ConditionalOnMissingBean(CloseableHttpClient.class) 83 public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory, 84 HttpClientConnectionManager connectionManager, IClientConfig config) { 85 RibbonProperties ribbon = RibbonProperties.from(config); 86 Boolean followRedirects = ribbon.isFollowRedirects(); 87 Integer connectTimeout = ribbon.connectTimeout(); 88 RequestConfig defaultRequestConfig = RequestConfig.custom() 89 .setConnectTimeout(connectTimeout) 90 .setRedirectsEnabled(followRedirects).build(); 91 this.httpClient = httpClientFactory.createBuilder() 92 .setDefaultRequestConfig(defaultRequestConfig) 93 .setConnectionManager(connectionManager).build(); 94 return httpClient; 95 } 96 } 97 }
View Code
③ 默認配置下的 RestTemplate 的調用過程大致可以用下圖來表示。
3、啟用 RestClient
① 啟用 RestClient
可以添加如下配置啟用 RestClient:
1 ribbon: 2 # 關閉 httpclient 3 httpclient: 4 enabled: false 5 # 啟用 RestClient 6 restclient: 7 enabled: true 8 # 啟用 RestClient 9 http: 10 client: 11 enabled: true
進入 RestClientRibbonConfiguration 可以看到,只要 ribbon.http.client.enabled、ribbon.restclient.enabled 其中一個配置了啟用,就可以啟用 RestClient。
1 @SuppressWarnings("deprecation") 2 @Configuration(proxyBeanMethods = false) 3 // 啟用條件 ConditionalOnRibbonRestClient 4 @RibbonAutoConfiguration.ConditionalOnRibbonRestClient 5 class RestClientRibbonConfiguration { 6 @RibbonClientName 7 private String name = "client"; 8 9 // RestClient 已過期 10 @Bean 11 @Lazy 12 @ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class) 13 public RestClient ribbonRestClient(IClientConfig config, ILoadBalancer loadBalancer, 14 ServerIntrospector serverIntrospector, RetryHandler retryHandler) { 15 RestClient client = new RibbonClientConfiguration.OverrideRestClient(config, serverIntrospector); 16 client.setLoadBalancer(loadBalancer); 17 client.setRetryHandler(retryHandler); 18 return client; 19 } 20 21 } 22 23 @Target({ ElementType.TYPE, ElementType.METHOD }) 24 @Retention(RetentionPolicy.RUNTIME) 25 @Documented 26 @Conditional(OnRibbonRestClientCondition.class) 27 @interface ConditionalOnRibbonRestClient { 28 } 29 30 private static class OnRibbonRestClientCondition extends AnyNestedCondition { 31 @Deprecated // remove in Edgware" 32 @ConditionalOnProperty("ribbon.http.client.enabled") 33 static class ZuulProperty { 34 } 35 36 @ConditionalOnProperty("ribbon.restclient.enabled") 37 static class RibbonProperty { 38 } 39 }
RestClient 繼承自 AbstractLoadBalancerAwareClient。需要注意的是,RestClient 已經過期,所以生產環境中我們就不要啟用 RestTemplate 了。
1 @Deprecated 2 public class RestClient extends AbstractLoadBalancerAwareClient<HttpRequest, HttpResponse> { 3 4 }
② LoadBalancerContext 類體系結構
負載均衡上下文 LoadBalancerContext 體系的類結構如下。可以看出,Ribbon 是支援 Feign、OkHttp、HttpClient、RestClient 的。默認配置下使用的實現類是 RibbonLoadBalancerContext。
③ RestTemplate 的 ClientHttpRequest 工廠類配置
接著看 RibbonAutoConfiguration 中有如下的配置,跟前面 RestClientRibbonConfiguration 也是一樣,滿足 @ConditionalOnRibbonRestClient 的條件。
可以看到,它會創建 RibbonClientHttpRequestFactory 並設置到 RestTemplate 中,也就是說,這時 RestTemplate 中的 requestFactory 就不是默認的 SimpleClientHttpRequestFactory 了,而是 RibbonClientHttpRequestFactory。
1 @Configuration(proxyBeanMethods = false) 2 @ConditionalOnClass(HttpRequest.class) 3 @ConditionalOnRibbonRestClient 4 protected static class RibbonClientHttpRequestFactoryConfiguration { 5 @Autowired 6 private SpringClientFactory springClientFactory; 7 8 @Bean 9 public RestTemplateCustomizer restTemplateCustomizer( 10 final RibbonClientHttpRequestFactory ribbonClientHttpRequestFactory) { 11 // RestTemplate 設置 requestFactory 為 RibbonClientHttpRequestFactory 12 return restTemplate -> restTemplate 13 .setRequestFactory(ribbonClientHttpRequestFactory); 14 } 15 16 // ClientHttpRequest 工廠類 => RibbonClientHttpRequestFactory 17 @Bean 18 public RibbonClientHttpRequestFactory ribbonClientHttpRequestFactory() { 19 return new RibbonClientHttpRequestFactory(this.springClientFactory); 20 } 21 }
而且,由於這裡配置了 RestTemplateCustomizer,原本默認配置下,在 LoadBalancerAutoConfiguration 中創建 RestTemplateCustomizer 的方法就不會生效了。
LoadBalancerAutoConfiguration 中的 RestTemplateCustomizer 是向 RestTemplate 中添加 LoadBalancerInterceptor 攔截器,所以在啟用了 RestClient 的情況下,原本的 LoadBalancerInterceptor 就不會生效了。


1 @Configuration(proxyBeanMethods = false) 2 @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate") 3 static class LoadBalancerInterceptorConfig { 4 5 @Bean 6 public LoadBalancerInterceptor ribbonInterceptor( 7 LoadBalancerClient loadBalancerClient, 8 LoadBalancerRequestFactory requestFactory) { 9 return new LoadBalancerInterceptor(loadBalancerClient, requestFactory); 10 } 11 12 @Bean 13 @ConditionalOnMissingBean 14 public RestTemplateCustomizer restTemplateCustomizer( 15 final LoadBalancerInterceptor loadBalancerInterceptor) { 16 return restTemplate -> { 17 List<ClientHttpRequestInterceptor> list = new ArrayList<>( 18 restTemplate.getInterceptors()); 19 list.add(loadBalancerInterceptor); 20 restTemplate.setInterceptors(list); 21 }; 22 } 23 }
View Code
那麼 RestTemplate 的 doExecute 方法中,在調用 createRequest 方法創建 ClientHttpRequest 時,就會用 RibbonClientHttpRequestFactory 來創建,進去可以看到 ClientHttpRequest 的實際類型就是 RibbonHttpRequest。
1 public ClientHttpRequest createRequest(URI originalUri, HttpMethod httpMethod) throws IOException { 2 String serviceId = originalUri.getHost(); 3 if (serviceId == null) { 4 throw new IOException("Invalid hostname in the URI [" + originalUri.toASCIIString() + "]"); 5 } 6 IClientConfig clientConfig = this.clientFactory.getClientConfig(serviceId); 7 RestClient client = this.clientFactory.getClient(serviceId, RestClient.class); 8 HttpRequest.Verb verb = HttpRequest.Verb.valueOf(httpMethod.name()); 9 10 return new RibbonHttpRequest(originalUri, verb, client, clientConfig); 11 }
調用 RibbonHttpRequest 的 execute 方法,實際組中是調用了它的 executeInternal 方法,然後最後是使用 RestClient 來發起負載均衡的調用。
1 protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException { 2 try { 3 // ... 4 HttpRequest request = builder.build(); 5 // client => RestClient 6 HttpResponse response = client.executeWithLoadBalancer(request, config); 7 return new RibbonHttpResponse(response); 8 } 9 catch (Exception e) { 10 throw new IOException(e); 11 } 12 }
④ RestClient HTTP 調用
RestClient 的 executeWithLoadBalancer 實際是進入到父類 AbstractLoadBalancerAwareClient 的 executeWithLoadBalancer 方法中。
從這個方法可以知道,主要的負載均衡請求是在 LoadBalancerCommand 中的,LoadBalancerCommand 必定會通過負載均衡器 ILoadBalancer 得到一個 Server,然後通過 submit 的這個 ServerOperation 對原始URI進行重構,重構之後調用 RestClient 的 execute 發起HTTP請求。
1 public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException { 2 // 負載均衡命令 3 LoadBalancerCommand<T> command = buildLoadBalancerCommand(request, requestConfig); 4 5 try { 6 // 發起負載均衡請求 7 return command.submit( 8 new ServerOperation<T>() { 9 @Override 10 public Observable<T> call(Server server) { 11 // 重構 URI,將服務名用 Server 的 IP 和埠替換 12 URI finalUri = reconstructURIWithServer(server, request.getUri()); 13 S requestForServer = (S) request.replaceUri(finalUri); 14 try { 15 // execute 發起調用,實際調用的是 RestClient 中的 execute 16 return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig)); 17 } 18 catch (Exception e) { 19 return Observable.error(e); 20 } 21 } 22 }) 23 .toBlocking() 24 .single(); 25 } catch (Exception e) { 26 //.... 27 } 28 }
再看 RestClient 的 execute 方法,最終可以發現,RestClient 其實是使用基於 jersey 的 WebResource 來發起 HTTP 請求的。


1 private HttpResponse execute(HttpRequest.Verb verb, URI uri, 2 Map<String, Collection<String>> headers, Map<String, Collection<String>> params, 3 IClientConfig overriddenClientConfig, Object requestEntity) throws Exception { 4 // ... 5 // WebResource 是基於 jersey 封裝的 HTTP 客戶端組件 6 WebResource xResource = restClient.resource(uri.toString()); 7 ClientResponse jerseyResponse; 8 Builder b = xResource.getRequestBuilder(); 9 Object entity = requestEntity; 10 11 switch (verb) { 12 case GET: 13 jerseyResponse = b.get(ClientResponse.class); 14 break; 15 case POST: 16 jerseyResponse = b.post(ClientResponse.class, entity); 17 break; 18 case PUT: 19 jerseyResponse = b.put(ClientResponse.class, entity); 20 break; 21 case DELETE: 22 jerseyResponse = b.delete(ClientResponse.class); 23 break; 24 case HEAD: 25 jerseyResponse = b.head(); 26 break; 27 case OPTIONS: 28 jerseyResponse = b.options(ClientResponse.class); 29 break; 30 default: 31 throw new ClientException( 32 ClientException.ErrorType.GENERAL, 33 "You have to one of the REST verbs such as GET, POST etc."); 34 } 35 36 thisResponse = new HttpClientResponse(jerseyResponse, uri, overriddenClientConfig); 37 if (thisResponse.getStatus() == 503){ 38 thisResponse.close(); 39 throw new ClientException(ClientException.ErrorType.SERVER_THROTTLED); 40 } 41 return thisResponse; 42 }
View Code
⑤ 最後,RestTemplate 基於 RestClient 的請求流程可以用下圖來做個總結。
4、Apache HttpClient 或 OkHttp 對 RestTemplate 不生效(BUG?)
① Apache HttpClient
默認情況下,ribbon.httpclient.enabled=true,在 HttpClientRibbonConfiguration 中會初始化 apache httpcomponents 相關的組件,前已經分析過了,但是在 RestTemplate 中並未使用相關的組件。
也就是說,默認情況下啟用了 apache httpcomponents,但是 RestTemplate 最後是使用 HttpURLConnection 來發起 HTTP 請求的,而不是配置的 CloseableHttpClient。
② OkHttp
首先需要加入 OkHttp 的依賴:
1 <dependency> 2 <groupId>com.squareup.okhttp3</groupId> 3 <artifactId>okhttp</artifactId> 4 </dependency>
然後添加如下配置就可以啟用 OkHttp:
1 ribbon:
2 httpclient:
3 enabled: false
4 # 啟用 okhttp
5 okhttp:
6 enabled: true
配置 ribbon.okhttp.enabled=true 後,在 OkHttpRibbonConfiguration 中會初始化 OkHttp 相關的組件。
但是調試之後會發現,其實它還是走的默認的流程,就是最終用 HttpURLConnection 發起 HTTP 請求,跟 httpcomponents 是一樣的效果。


1 @Configuration(proxyBeanMethods = false) 2 @ConditionalOnProperty("ribbon.okhttp.enabled") 3 @ConditionalOnClass(name = "okhttp3.OkHttpClient") 4 public class OkHttpRibbonConfiguration { 5 6 @RibbonClientName 7 private String name = "client"; 8 9 @Bean 10 @ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class) 11 @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") 12 public RetryableOkHttpLoadBalancingClient retryableOkHttpLoadBalancingClient( 13 IClientConfig config, ServerIntrospector serverIntrospector, 14 ILoadBalancer loadBalancer, RetryHandler retryHandler, 15 LoadBalancedRetryFactory loadBalancedRetryFactory, OkHttpClient delegate, 16 RibbonLoadBalancerContext ribbonLoadBalancerContext) { 17 RetryableOkHttpLoadBalancingClient client = new RetryableOkHttpLoadBalancingClient( 18 delegate, config, serverIntrospector, loadBalancedRetryFactory); 19 client.setLoadBalancer(loadBalancer); 20 client.setRetryHandler(retryHandler); 21 client.setRibbonLoadBalancerContext(ribbonLoadBalancerContext); 22 Monitors.registerObject("Client_" + this.name, client); 23 return client; 24 } 25 26 @Bean 27 @ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class) 28 @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate") 29 public OkHttpLoadBalancingClient okHttpLoadBalancingClient(IClientConfig config, 30 ServerIntrospector serverIntrospector, ILoadBalancer loadBalancer, 31 RetryHandler retryHandler, OkHttpClient delegate) { 32 OkHttpLoadBalancingClient client = new OkHttpLoadBalancingClient(delegate, config, 33 serverIntrospector); 34 client.setLoadBalancer(loadBalancer); 35 client.setRetryHandler(retryHandler); 36 Monitors.registerObject("Client_" + this.name, client); 37 return client; 38 } 39 40 @Configuration(proxyBeanMethods = false) 41 protected static class OkHttpClientConfiguration { 42 43 private OkHttpClient httpClient; 44 45 @Bean 46 @ConditionalOnMissingBean(ConnectionPool.class) 47 public ConnectionPool httpClientConnectionPool(IClientConfig config, 48 OkHttpClientConnectionPoolFactory connectionPoolFactory) { 49 RibbonProperties ribbon = RibbonProperties.from(config); 50 int maxTotalConnections = ribbon.maxTotalConnections(); 51 long timeToLive = ribbon.poolKeepAliveTime(); 52 TimeUnit ttlUnit = ribbon.getPoolKeepAliveTimeUnits(); 53 return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit); 54 } 55 56 @Bean 57 @ConditionalOnMissingBean(OkHttpClient.class) 58 public OkHttpClient client(OkHttpClientFactory httpClientFactory, 59 ConnectionPool connectionPool, IClientConfig config) { 60 RibbonProperties ribbon = RibbonProperties.from(config); 61 this.httpClient = httpClientFactory.createBuilder(false) 62 .connectTimeout(ribbon.connectTimeout(), TimeUnit.MILLISECONDS) 63 .readTimeout(ribbon.readTimeout(), TimeUnit.MILLISECONDS) 64 .followRedirects(ribbon.isFollowRedirects()) 65 .connectionPool(connectionPool).build(); 66 return this.httpClient; 67 } 68 69 @PreDestroy 70 public void destroy() { 71 if (httpClient != null) { 72 httpClient.dispatcher().executorService().shutdown(); 73 httpClient.connectionPool().evictAll(); 74 } 75 } 76 77 } 78 79 }
View Cod
③ 啟用 HttpClient 或 OkHttp 不生效的原因
經過前面的分析,可以知道啟用 apache httpcomponents 或者 OkHttp,對 RestTemplate 都沒有起作用,最終還是用 HttpURLConnection 發起 HTTP 請求。那為什麼為出現這種情況呢?我們可以看下 RestTemplate 的 setRequestFactory 方法。
通過 RestTemplate 的 setRequestFactory 方法的注釋也可以了解到,默認的 requestFactory 是 SimpleClientHttpRequestFactory,它是基於 JDK 標準 HTTP 庫的 HttpURLConnection。
默認的 HttpURLConnection 不支援 PATCH,如果想支援,需設置為 Apache HttpComponents 或 OkHttp 的 request factory。
1 /** 2 * Set the request factory that this accessor uses for obtaining client request handles. 3 * <p>The default is a {@link SimpleClientHttpRequestFactory} based on the JDK's own 4 * HTTP libraries ({@link java.net.HttpURLConnection}). 5 * <p><b>Note that the standard JDK HTTP library does not support the HTTP PATCH method. 6 * Configure the Apache HttpComponents or OkHttp request factory to enable PATCH.</b> 7 * @see #createRequest(URI, HttpMethod) 8 * @see SimpleClientHttpRequestFactory 9 * @see org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory 10 * @see org.springframework.http.client.OkHttp3ClientHttpRequestFactory 11 */ 12 public void setRequestFactory(ClientHttpRequestFactory requestFactory) { 13 Assert.notNull(requestFactory, "ClientHttpRequestFactory must not be null"); 14 this.requestFactory = requestFactory; 15 }
ClientHttpRequestFactory 體系類結構如下:
那 RestClient 又是如何生效的呢?通過上一節的分析可以知道,在 RibbonAutoConfiguration 中有如下的配置,這個 RibbonClientHttpRequestFactoryConfiguration 通過自定義 RestTemplateCustomizer 向 RestTemplate 設置了 requestFactory 為 RibbonClientHttpRequestFactory。
1 @Configuration(proxyBeanMethods = false) 2 @ConditionalOnClass(HttpRequest.class) 3 @ConditionalOnRibbonRestClient 4 protected static class RibbonClientHttpRequestFactoryConfiguration { 5 @Autowired 6 private SpringClientFactory springClientFactory; 7 8 @Bean 9 public RestTemplateCustomizer restTemplateCustomizer(final RibbonClientHttpRequestFactory ribbonClientHttpRequestFactory) { 10 return restTemplate -> restTemplate.setRequestFactory(ribbonClientHttpRequestFactory); 11 } 12 13 @Bean 14 public RibbonClientHttpRequestFactory ribbonClientHttpRequestFactory() { 15 return new RibbonClientHttpRequestFactory(this.springClientFactory); 16 } 17 }
RibbonClientHttpRequestFactory 是對應 RestClient 的,也就是說要啟用 OkHttp 或 HttpClient,還需自己創建對應的 ClientHttpRequestFactory,並設置給 RestTemplate。從上面的類結構可以看出,是提供了 HttpComponentsClientHttpRequestFactory 和 OkHttp3ClientHttpRequestFactory 工廠類了的。
這裡其實也比較奇怪,既然啟用了 apache httpcomponents 或者 OkHttp,卻沒有創建默認的 ClientHttpRequestFactory 實現類設置給 RestTemplate,感覺這是 spring-cloud-netflix-ribbon 的一個 BUG。
5、訂製 RestTemplate 使用 Apache httpcomponents
如果想讓 RestTemplate 使用 httpcomponents 的組件,就需要自己創建一個 ClientHttpRequestFactory,並設置給 RestTemplate。下面我們一步步來看看如何修復這個問題。
① 設置 HttpComponentsClientHttpRequestFactory
httpcomponents 中提供的 ClientHttpRequestFactory 實現類是 HttpComponentsClientHttpRequestFactory,但是並不能直接使用這個工廠類,因為它創建的 HttpComponentsClientHttpRequest 不具備重試的能力,它直接使用 CloseableHttpClient 執行請求,雖然有超時的功能,但不能重試。而且,它本質上也沒有負載均衡的能力,需要藉助 LoadBalancerInterceptor 攔截器來重構 URI。
1 final class HttpComponentsClientHttpRequest extends AbstractBufferingClientHttpRequest { 2 private final HttpClient httpClient; 3 private final HttpUriRequest httpRequest; 4 private final HttpContext httpContext; 5 6 @Override 7 protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) throws IOException { 8 // ... 9 // httpClient => CloseableHttpClient 10 HttpResponse httpResponse = this.httpClient.execute(this.httpRequest, this.httpContext); 11 return new HttpComponentsClientHttpResponse(httpResponse); 12 } 13 }
所以,如果不需要重試的功能,可以直接創建一個 HttpComponentsClientHttpRequest,並設置給 RestTemplate 即可。這樣就會使用 LoadBalancerInterceptor 來做負載均衡,重構 URI,然後用 HttpComponentsClientHttpRequest 來執行請求。
1 @Bean 2 @LoadBalanced 3 public RestTemplate restTemplate() { 4 HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(); 5 RestTemplate restTemplate = new RestTemplate(); 6 restTemplate.setRequestFactory(requestFactory); 7 return restTemplate; 8 }
② 訂製 apache ClientHttpRequestFactory
如果想讓 RestTemplate 即有負載均衡的能力,又能使用 apache HttpComponents 組件,且具備重試的功能,我們就需要自己訂製 ClientHttpRequestFactory 了。關於重試後面再單獨來講。
對比 RestClient 可以發現,RibbonClientHttpRequestFactory 創建的 RibbonHttpRequest 其實是使用 RestClient 執行請求,而 RestClient 內部使用 LoadBalancerCommand 來進行重試。
類似的,我們至少要用上已經配置好的 RibbonLoadBalancingHttpClient 來執行請求,所以需要自定義一個類似的 RibbonHttpRequest 。
1)訂製 apache ClientHttpRequest
創建 ApacheClientHttpRequest 繼承自 RibbonHttpRequest,核心的點在於要注入 RibbonLoadBalancingHttpClient,如果要支援重試,需注入 RetryableRibbonLoadBalancingHttpClient。RetryableRibbonLoadBalancingHttpClient 在引入 spring-retry 後才會創建,這個後面分析重試時再看。
然後在 executeInternal 根據 retryable 判斷,如果要重試,就調用 execute 方法,看 RetryableRibbonLoadBalancingHttpClient 的源碼可以發現,它本身是支援負載均衡的,會自動選擇 Server。
如果不需要重試,就需要調用 executeWithLoadBalancer,它是利用 LoadBalancerCommand 來提交請求,就跟 RestClient 是一樣的了。但是不一樣的地方是 RibbonLoadBalancingHttpClient 的 executeWithLoadBalancer 是不會進行重試的,這個也放到後面分析。


1 package com.lyyzoo.sunny.register.ribbon.apache; 2 3 import java.io.IOException; 4 import java.net.URI; 5 import java.util.ArrayList; 6 7 import com.netflix.client.config.IClientConfig; 8 import com.netflix.client.http.HttpResponse; 9 import org.springframework.cloud.netflix.ribbon.RibbonHttpRequest; 10 import org.springframework.cloud.netflix.ribbon.RibbonHttpResponse; 11 import org.springframework.cloud.netflix.ribbon.apache.RetryableRibbonLoadBalancingHttpClient; 12 import org.springframework.cloud.netflix.ribbon.apache.RibbonApacheHttpRequest; 13 import org.springframework.cloud.netflix.ribbon.apache.RibbonLoadBalancingHttpClient; 14 import org.springframework.cloud.netflix.ribbon.support.RibbonCommandContext; 15 import org.springframework.http.HttpHeaders; 16 import org.springframework.http.HttpMethod; 17 import org.springframework.http.client.ClientHttpResponse; 18 import org.springframework.util.LinkedMultiValueMap; 19 20 /** 21 * Apache ClientHttpRequest 22 * 23 * @author bojiangzhou 24 */ 25 public class ApacheClientHttpRequest extends RibbonHttpRequest { 26 27 private final URI uri; 28 29 private final HttpMethod httpMethod; 30 31 private final String serviceId; 32 33 private final RibbonLoadBalancingHttpClient client; 34 35 private final IClientConfig config; 36 /** 37 * 是否重試 38 */ 39 private final boolean retryable; 40 41 public ApacheClientHttpRequest(URI uri, 42 HttpMethod httpMethod, 43 String serviceId, 44 RibbonLoadBalancingHttpClient client, 45 IClientConfig config, 46 boolean retryable) { 47 super(uri, null, null, config); 48 this.uri = uri; 49 this.httpMethod = httpMethod; 50 this.serviceId = serviceId; 51 this.client = client; 52 this.config = config; 53 this.retryable = retryable; 54 if (retryable && !(client instanceof RetryableRibbonLoadBalancingHttpClient)) { 55 throw new IllegalArgumentException("Retryable client must be RetryableRibbonLoadBalancingHttpClient"); 56 } 57 } 58 59 @Override 60 protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException { 61 try { 62 RibbonCommandContext ribbonCommandContext = new RibbonCommandContext(serviceId, httpMethod.name(), 63 uri.toString(), retryable, headers, new LinkedMultiValueMap<>(), null, new ArrayList<>()); 64 65 RibbonApacheHttpRequest request = new RibbonApacheHttpRequest(ribbonCommandContext); 66 67 HttpResponse response; 68 if (retryable) { 69 // RetryableRibbonLoadBalancingHttpClient 本身具備負載均衡的能力 70 response = client.execute(request, config); 71 } else { 72 // RibbonLoadBalancingHttpClient 需調用 executeWithLoadBalancer 才具備負載均衡的能力 73 response = client.executeWithLoadBalancer(request, config); 74 } 75 76 return new RibbonHttpResponse(response); 77 } catch (Exception e) { 78 throw new IOException(e); 79 } 80 } 81 }
View Code
2)訂製 apache ClientHttpRequestFactory
創建 ApacheClientHttpRequestFactory 繼承自 HttpComponentsClientHttpRequestFactory,主要是在 createRequest 方法中創建自定義的 ApacheClientHttpRequest。RibbonLoadBalancingHttpClient 可以從 SpringClientFactory 中獲取。


1 package com.lyyzoo.sunny.register.ribbon.apache; 2 3 import java.io.IOException; 4 import java.net.URI; 5 6 import com.netflix.client.config.IClientConfig; 7 import org.springframework.cloud.netflix.ribbon.SpringClientFactory; 8 import org.springframework.cloud.netflix.ribbon.apache.RibbonLoadBalancingHttpClient; 9 import org.springframework.http.HttpMethod; 10 import org.springframework.http.client.ClientHttpRequest; 11 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory; 12 import org.springframework.lang.NonNull; 13 14 /** 15 * Apache HttpComponents ClientHttpRequest factory 16 * 17 * @author bojiangzhou 18 */ 19 public class ApacheClientHttpRequestFactory extends HttpComponentsClientHttpRequestFactory { 20 21 private final SpringClientFactory clientFactory; 22 private final boolean retryable; 23 24 public ApacheClientHttpRequestFactory(SpringClientFactory clientFactory, boolean retryable) { 25 this.clientFactory = clientFactory; 26 this.retryable = retryable; 27 } 28 29 @Override 30 @NonNull 31 public ClientHttpRequest createRequest(URI originalUri, HttpMethod httpMethod) throws IOException { 32 String serviceId = originalUri.getHost(); 33 if (serviceId == null) { 34 throw new IOException( 35 "Invalid hostname in the URI [" + originalUri.toASCIIString() + "]"); 36 } 37 IClientConfig clientConfig = this.clientFactory.getClientConfig(serviceId); 38 RibbonLoadBalancingHttpClient httpClient = this.clientFactory.getClient(serviceId, RibbonLoadBalancingHttpClient.class); 39 40 return new ApacheClientHttpRequest(originalUri, httpMethod, serviceId, httpClient, clientConfig, retryable); 41 } 42 }
View Code
3)訂製 apache ClientHttpRequestFactory 配置類
跟 RestClient 的配置類類似,訂製 ApacheClientHttpRequestFactory 的配置類,同樣的,默認啟用 httpclient。在存在 RetryTemplate 時,就設置 ApacheClientHttpRequestFactory 的 retryable 參數為 true,否則為 false。
然後自定義 RestTemplateCustomizer,將 ApacheClientHttpRequestFactory 設置到 RestTemplate 中,注意這時 LoadBalancerInterceptor 就不會添加到 RestTemplate 中了。


1 package com.lyyzoo.sunny.register.ribbon.apache; 2 3 import org.apache.http.client.HttpClient; 4 import org.springframework.beans.factory.annotation.Autowired; 5 import org.springframework.boot.autoconfigure.AutoConfigureAfter; 6 import org.springframework.boot.autoconfigure.AutoConfigureBefore; 7 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 8 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 9 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass; 10 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; 11 import org.springframework.cloud.client.loadbalancer.AsyncLoadBalancerAutoConfiguration; 12 import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; 13 import org.springframework.cloud.client.loadbalancer.RestTemplateCustomizer; 14 import org.springframework.cloud.netflix.ribbon.SpringClientFactory; 15 import org.springframework.context.annotation.Bean; 16 import org.springframework.context.annotation.Configuration; 17 import org.springframework.web.client.RestTemplate; 18 19 /** 20 * 21 * @author bojiangzhou 22 */ 23 @Configuration 24 @ConditionalOnClass(RestTemplate.class) 25 @AutoConfigureAfter(name = "org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration") 26 @AutoConfigureBefore({LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class}) 27 @ConditionalOnProperty(name = "ribbon.httpclient.restTemplate.enabled", matchIfMissing = true) 28 public class ApacheClientHttpRequestFactoryConfiguration { 29 30 @Configuration(proxyBeanMethods = false) 31 @ConditionalOnClass(HttpClient.class) 32 @ConditionalOnProperty(name = "ribbon.httpclient.enabled", matchIfMissing = true) 33 static class HttpComponentsClientHttpRequestFactoryConfiguration { 34 35 @Autowired 36 private SpringClientFactory springClientFactory; 37 38 @Bean 39 @ConditionalOnMissingBean 40 public RestTemplateCustomizer restTemplateCustomizer( 41 final ApacheClientHttpRequestFactory apacheClientHttpRequestFactory) { 42 return restTemplate -> restTemplate 43 .setRequestFactory(apacheClientHttpRequestFactory); 44 } 45 46 @Bean 47 @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate") 48 public ApacheClientHttpRequestFactory apacheClientHttpRequestFactory() { 49 return new ApacheClientHttpRequestFactory(springClientFactory, false); 50 } 51 52 @Bean 53 @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") 54 public ApacheClientHttpRequestFactory retryableApacheClientHttpRequestFactory() { 55 return new ApacheClientHttpRequestFactory(springClientFactory, true); 56 } 57 } 58 }
View Code
4)簡單調試下
配置好之後,把 demo-consumer 服務啟動起來,簡單測試下。
a) 首先請求會進入到 RestTemplate 的 doExecute 中,然後通過 createRequest,調用 ApacheClientHttpRequestFactory 創建 ApacheClientHttpRequest。
b) 接著調用 ApacheClientHttpRequest 的 execute 方法,在 ApacheClientHttpRequest 的 executeInternal 中,就會調用 RibbonLoadBalancingHttpClient 的 executeWithLoadBalancer 方法。
c) 最後,進入 RibbonLoadBalancingHttpClient 的 execute 方法中,它又將請求轉給了代理對象 delegate 來執行,delegate 就是在 HttpClientRibbonConfiguration 中配置的 CloseableHttpClient 對象,實際類型是 InternalHttpClient。
經過驗證,通過自定義的配置,最終使得 RestTemplate 可以使用 apache httpcomponents 組件來執行 HTTP 請求。重試那塊後面再來研究。
③ 還是用一張圖來總結下 RestTemplate 基於 apache HttpClient 後的執行流程
6、訂製 RestTemplate 使用 OkHttp
① 設置 OkHttp3ClientHttpRequestFactory
類似的,可以給 RestTemplate 直接設置 OkHttp3ClientHttpRequestFactory,但它同樣也不具備重試的能力。
1 @Bean 2 @LoadBalanced 3 public RestTemplate restTemplate() { 4 OkHttp3ClientHttpRequestFactory requestFactory = new OkHttp3ClientHttpRequestFactory(); 5 RestTemplate restTemplate = new RestTemplate(); 6 restTemplate.setRequestFactory(requestFactory); 7 return restTemplate; 8 }
② 訂製 OkHttp ClientHttpRequestFactory
與訂製 apache httpcomponents 類似,我這裡就直接把三個類的程式碼放出來了。
a) OkHttpClientHttpRequest:


1 package com.lyyzoo.sunny.register.ribbon.okhttp; 2 3 import java.io.IOException; 4 import java.net.URI; 5 import java.util.ArrayList; 6 7 import com.netflix.client.config.IClientConfig; 8 import com.netflix.client.http.HttpResponse; 9 import org.springframework.cloud.netflix.ribbon.RibbonHttpRequest; 10 import org.springframework.cloud.netflix.ribbon.RibbonHttpResponse; 11 import org.springframework.cloud.netflix.ribbon.okhttp.OkHttpLoadBalancingClient; 12 import org.springframework.cloud.netflix.ribbon.okhttp.OkHttpRibbonRequest; 13 import org.springframework.cloud.netflix.ribbon.okhttp.RetryableOkHttpLoadBalancingClient; 14 import org.springframework.cloud.netflix.ribbon.support.RibbonCommandContext; 15 import org.springframework.http.HttpHeaders; 16 import org.springframework.http.HttpMethod; 17 import org.springframework.http.client.ClientHttpResponse; 18 import org.springframework.util.LinkedMultiValueMap; 19 20 /** 21 * OkHttp ClientHttpRequest 22 * 23 * @author bojiangzhou 24 */ 25 public class OkHttpClientHttpRequest extends RibbonHttpRequest { 26 27 private final URI uri; 28 29 private final HttpMethod httpMethod; 30 31 private final String serviceId; 32 33 private final OkHttpLoadBalancingClient client; 34 35 private final IClientConfig config; 36 /** 37 * 是否重試 38 */ 39 private final boolean retryable; 40 41 public OkHttpClientHttpRequest(URI uri, 42 HttpMethod httpMethod, 43 String serviceId, 44 OkHttpLoadBalancingClient client, 45 IClientConfig config, 46 boolean retryable) { 47 super(uri, null, null, config); 48 this.uri = uri; 49 this.httpMethod = httpMethod; 50 this.serviceId = serviceId; 51 this.client = client; 52 this.config = config; 53 this.retryable = retryable; 54 if (retryable && !(client instanceof RetryableOkHttpLoadBalancingClient)) { 55 throw new IllegalArgumentException("Retryable client must be RetryableOkHttpLoadBalancingClient"); 56 } 57 } 58 59 @Override 60 protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException { 61 try { 62 RibbonCommandContext ribbonCommandContext = new RibbonCommandContext(serviceId, httpMethod.name(), 63 uri.toString(), retryable, headers, new LinkedMultiValueMap<>(), null, new ArrayList<>()); 64 65 OkHttpRibbonRequest request = new OkHttpRibbonRequest(ribbonCommandContext); 66 67 HttpResponse response; 68 if (retryable) { 69 // RetryableRibbonLoadBalancingHttpClient 本身具備負載均衡的能力 70 response = client.execute(request, config); 71 } else { 72 // RibbonLoadBalancingHttpClient 需調用 executeWithLoadBalancer 才具備負載均衡的能力 73 response = client.executeWithLoadBalancer(request, config); 74 } 75 76 return new RibbonHttpResponse(response); 77 } catch (Exception e) { 78 throw new IOException(e); 79 } 80 } 81 }
View Code
b) OkHttpClientHttpRequestFactory


1 package com.lyyzoo.sunny.register.ribbon.okhttp; 2 3 import java.io.IOException; 4 import java.net.URI; 5 6 import com.netflix.client.config.IClientConfig; 7 import org.springframework.cloud.netflix.ribbon.SpringClientFactory; 8 import org.springframework.cloud.netflix.ribbon.okhttp.OkHttpLoadBalancingClient; 9 import org.springframework.http.HttpMethod; 10 import org.springframework.http.client.ClientHttpRequest; 11 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory; 12 import org.springframework.lang.NonNull; 13 14 /** 15 * OkHttp ClientHttpRequest factory 16 * 17 * @author bojiangzhou 18 */ 19 public class OkHttpClientHttpRequestFactory extends HttpComponentsClientHttpRequestFactory { 20 21 private final SpringClientFactory clientFactory; 22 private final boolean retryable; 23 24 public OkHttpClientHttpRequestFactory(SpringClientFactory clientFactory, boolean retryable) { 25 this.clientFactory = clientFactory; 26 this.retryable = retryable; 27 } 28 29 @Override 30 @NonNull 31 public ClientHttpRequest createRequest(URI originalUri, HttpMethod httpMethod) throws IOException { 32 String serviceId = originalUri.getHost(); 33 if (serviceId == null) { 34 throw new IOException( 35 "Invalid hostname in the URI [" + originalUri.toASCIIString() + "]"); 36 } 37 IClientConfig clientConfig = this.clientFactory.getClientConfig(serviceId); 38 OkHttpLoadBalancingClient httpClient = this.clientFactory.getClient(serviceId, OkHttpLoadBalancingClient.class); 39 40 return new OkHttpClientHttpRequest(originalUri, httpMethod, serviceId, httpClient, clientConfig, retryable); 41 } 42 }
View Code
c) OkHttpClientHttpRequestFactoryConfiguration


1 package com.lyyzoo.sunny.register.ribbon.okhttp; 2 3 import org.springframework.beans.factory.annotation.Autowired; 4 import org.springframework.boot.autoconfigure.AutoConfigureAfter; 5 import org.springframework.boot.autoconfigure.AutoConfigureBefore; 6 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 7 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 8 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass; 9 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; 10 import org.springframework.cloud.client.loadbalancer.AsyncLoadBalancerAutoConfiguration; 11 import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; 12 import org.springframework.cloud.client.loadbalancer.RestTemplateCustomizer; 13 import org.springframework.cloud.netflix.ribbon.SpringClientFactory; 14 import org.springframework.context.annotation.Bean; 15 import org.springframework.context.annotation.Configuration; 16 import org.springframework.web.client.RestTemplate; 17 18 /** 19 * 20 * @author bojiangzhou 21 */ 22 @Configuration 23 @ConditionalOnClass(RestTemplate.class) 24 @AutoConfigureAfter(name = "org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration") 25 @AutoConfigureBefore({LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class}) 26 @ConditionalOnProperty(name = "ribbon.okhttp.restTemplate.enabled", matchIfMissing = true) 27 public class OkHttpClientHttpRequestFactoryConfiguration { 28 29 @Configuration(proxyBeanMethods = false) 30 @ConditionalOnProperty("ribbon.okhttp.enabled") 31 @ConditionalOnClass(name = "okhttp3.OkHttpClient") 32 static class ClientHttpRequestFactoryConfiguration { 33 34 @Autowired 35 private SpringClientFactory springClientFactory; 36 37 @Bean 38 @ConditionalOnMissingBean 39 public RestTemplateCustomizer restTemplateCustomizer( 40 final OkHttpClientHttpRequestFactory okHttpClientHttpRequestFactory) { 41 return restTemplate -> restTemplate 42 .setRequestFactory(okHttpClientHttpRequestFactory); 43 } 44 45 @Bean 46 @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate") 47 public OkHttpClientHttpRequestFactory okHttpClientHttpRequestFactory() { 48 return new OkHttpClientHttpRequestFactory(springClientFactory, false); 49 } 50 51 @Bean 52 @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") 53 public OkHttpClientHttpRequestFactory retryableOkHttpClientHttpRequestFactory() { 54 return new OkHttpClientHttpRequestFactory(springClientFactory, true); 55 } 56 } 57 }
View Code
七、RestTemplate 超時重試
1、AbstractLoadBalancerAwareClient
① AbstractLoadBalancerAwareClient
通過上一節的分析,可以知道有重試功能的其實有兩個組件,一個是 Ribbon 的 LoadBalancerCommand,一個是 spring-retry 的 RetryTemplate。RetryableRibbonLoadBalancingHttpClient 和 RetryableOkHttpLoadBalancingClient 都要依賴 RetryTemplate,所以必須先引入 spring-retry 依賴,它們最終都是使用 RetryTemplate 實現請求重試的能力的。除了 RetryTemplate,其它客戶端想要獲取重試的功能,就要用 ribbon 中的 AbstractLoadBalancerAwareClient 相關的組件,並調用 executeWithLoadBalancer 方法。
再看下 AbstractLoadBalancerAwareClient 的體系,通過源碼可以了解到:
- RetryableFeignLoadBalancer、RetryableRibbonLoadBalancingHttpClient、RetryableOkHttpLoadBalancingClient 都是使用 RetryTemplate 實現重試功能的,也就是 spring-retry 的重試。
- RestClient、FeignLoadBalancer、RibbonLoadBalancingHttpClient、OkHttpLoadBalancingClient 是在 AbstractLoadBalancerAwareClient 中使用 LoadBalancerCommand 實現重試功能的,就是是 Ribbon 的重試。
② executeWithLoadBalancer
具體的 AbstractLoadBalancerAwareClient 客戶端想要負載均衡調用以及能進行重試,需調用 AbstractLoadBalancerAwareClient 的 executeWithLoadBalancer 方法。
在這個方法裡面,它先構建了 LoadBalancerCommand,然後用 command 提交了一個 ServerOperation,這個 ServerOperation 中對 URI 進行了 重構,轉到具體的 LoadBalancerContext 去執行請求。
1 public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException { 2 // 負載均衡命令 3 LoadBalancerCommand<T> command = buildLoadBalancerCommand(request, requestConfig); 4 5 try { 6 return command.submit( 7 new ServerOperation<T>() { 8 @Override 9 public Observable<T> call(Server server) { 10 // 重構URI 11 URI finalUri = reconstructURIWithServer(server, request.getUri()); 12 S requestForServer = (S) request.replaceUri(finalUri); 13 try { 14 // 使用具體的 AbstractLoadBalancerAwareClient 客戶端執行請求 15 return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig)); 16 } 17 catch (Exception e) { 18 return Observable.error(e); 19 } 20 } 21 }) 22 .toBlocking() 23 .single(); 24 } 25 }
再看 buildLoadBalancerCommand 方法,它首先會通過 getRequestSpecificRetryHandler 方法獲取請求重試處理器 RequestSpecificRetryHandler,而 getRequestSpecificRetryHandler 是一個抽象方法。這裡就要重點注意了。
1 // 抽象方法,獲取請求重試處理器 2 public abstract RequestSpecificRetryHandler getRequestSpecificRetryHandler(S request, IClientConfig requestConfig); 3 4 protected LoadBalancerCommand<T> buildLoadBalancerCommand(final S request, final IClientConfig config) { 5 // 獲取請求重試處理器 6 RequestSpecificRetryHandler handler = getRequestSpecificRetryHandler(request, config); 7 LoadBalancerCommand.Builder<T> builder = LoadBalancerCommand.<T>builder() 8 .withLoadBalancerContext(this) 9 .withRetryHandler(handler) 10 .withLoadBalancerURI(request.getUri()); 11 customizeLoadBalancerCommandBuilder(request, config, builder); 12 return builder.build(); 13 }
2、請求重試處理器 RequestSpecificRetryHandler
① 先了解下 RequestSpecificRetryHandler:
- 首先看它的構造方法,注意第一個參數和第二個參數,因為不同的 getRequestSpecificRetryHandler 方法實現,主要差異就在於這兩個參數。
- 然後看 isRetriableException,這個方法就是 LoadBalancerCommand 用來判斷異常後是否需要重試的方法,可以了解到 okToRetryOnAllErrors=true 時就可以重試,否則 okToRetryOnConnectErrors=true 才可能重試。需要注意的是就算這個方法返回 true 也不一定會重試,這跟重試次數也是有一定關係的。
1 public RequestSpecificRetryHandler(boolean okToRetryOnConnectErrors, boolean okToRetryOnAllErrors, RetryHandler baseRetryHandler, @Nullable IClientConfig requestConfig) { 2 Preconditions.checkNotNull(baseRetryHandler); 3 this.okToRetryOnConnectErrors = okToRetryOnConnectErrors; 4 this.okToRetryOnAllErrors = okToRetryOnAllErrors; 5 this.fallback = baseRetryHandler; 6 if (requestConfig != null) { 7 // 在同一個Server上重試的次數 8 if (requestConfig.containsProperty(CommonClientConfigKey.MaxAutoRetries)) { 9 retrySameServer = requestConfig.get(CommonClientConfigKey.MaxAutoRetries); 10 } 11 // 重試下一個Server的次數 12 if (requestConfig.containsProperty(CommonClientConfigKey.MaxAutoRetriesNextServer)) { 13 retryNextServer = requestConfig.get(CommonClientConfigKey.MaxAutoRetriesNextServer); 14 } 15 } 16 } 17 18 @Override 19 public boolean isRetriableException(Throwable e, boolean sameServer) { 20 // 所有錯誤都重試 21 if (okToRetryOnAllErrors) { 22 return true; 23 } 24 // ClientException 才可能重試 25 else if (e instanceof ClientException) { 26 ClientException ce = (ClientException) e; 27 if (ce.getErrorType() == ClientException.ErrorType.SERVER_THROTTLED) { 28 return !sameServer; 29 } else { 30 return false; 31 } 32 } 33 else { 34 // 連接錯誤才重試,就是拋出 SocketException 異常時才重試 35 return okToRetryOnConnectErrors && isConnectionException(e); 36 } 37 }
② 不同 LoadBalancerCommand 的 getRequestSpecificRetryHandler 實現
a)RestClient
默認配置下,RestClient 的 getRequestSpecificRetryHandler 會走到最後一步,okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 true,也就是說 isRetriableException 始終返回 true,也就是說拋出異常都會重試。
1 @Override 2 public RequestSpecificRetryHandler getRequestSpecificRetryHandler( 3 HttpRequest request, IClientConfig requestConfig) { 4 if (!request.isRetriable()) { 5 return new RequestSpecificRetryHandler(false, false, this.getRetryHandler(), requestConfig); 6 } 7 if (this.ncc.get(CommonClientConfigKey.OkToRetryOnAllOperations, false)) { 8 return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig); 9 } 10 if (request.getVerb() != HttpRequest.Verb.GET) { 11 return new RequestSpecificRetryHandler(true, false, this.getRetryHandler(), requestConfig); 12 } else { 13 // okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 true 14 return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig); 15 } 16 }
b)AbstractLoadBalancingClient
AbstractLoadBalancingClient 中的 getRequestSpecificRetryHandler 相當於一個默認實現,默認情況下 okToRetryOnAllOperations 為 false,最後也會到最後一步,即 okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 true,isRetriableException 始終返回 true。
1 @Override 2 public RequestSpecificRetryHandler getRequestSpecificRetryHandler(final S request, final IClientConfig requestConfig) { 3 // okToRetryOnAllOperations:是否所有操作都重試,默認 false 4 if (this.okToRetryOnAllOperations) { 5 return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig); 6 } 7 if (!request.getContext().getMethod().equals("GET")) { 8 return new RequestSpecificRetryHandler(true, false, this.getRetryHandler(), requestConfig); 9 } 10 else { 11 return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig); 12 } 13 }
c)RibbonLoadBalancingHttpClient
RibbonLoadBalancingHttpClient 也重載了 getRequestSpecificRetryHandler,但是它設置了 okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 false,isRetriableException 始終返回 false。
至此我們應該就知道為什麼調用 RibbonLoadBalancingHttpClient 的 executeWithLoadBalancer 不具備重試的功能的原因了。所以啟用 apache httpclient 時,RibbonLoadBalancingHttpClient 調用是不支援重試的。
1 @Override 2 public RequestSpecificRetryHandler getRequestSpecificRetryHandler(RibbonApacheHttpRequest request, IClientConfig requestConfig) { 3 // okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 false 4 return new RequestSpecificRetryHandler(false, false, RetryHandler.DEFAULT, requestConfig); 5 }
RetryableRibbonLoadBalancingHttpClient 中也重寫了 getRequestSpecificRetryHandler,同樣也是設置 okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 false。但是在引入 spring-retry 後,它會使用 RetryTemplate 實現重試的功能。
1 @Override 2 public RequestSpecificRetryHandler getRequestSpecificRetryHandler(RibbonApacheHttpRequest request, IClientConfig requestConfig) { 3 // okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 false 4 return new RequestSpecificRetryHandler(false, false, RetryHandler.DEFAULT, null); 5 }
d)OkHttpLoadBalancingClient
OkHttpLoadBalancingClient 並沒有重寫 getRequestSpecificRetryHandler,所以它是使用父類 AbstractLoadBalancingClient 中的方法,也就是 okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 true。所以,啟用 okhttp 時,OkHttpLoadBalancingClient 是支援重試的,這裡需要注意。
而 RetryableOkHttpLoadBalancingClient 跟 RetryableRibbonLoadBalancingHttpClient 一樣的重寫方式,使用 RetryTemplate 實現重試。
1 @Override 2 public RequestSpecificRetryHandler getRequestSpecificRetryHandler(RibbonApacheHttpRequest request, IClientConfig requestConfig) { 3 // okToRetryOnConnectErrors、okToRetryOnAllErrors 都為 false 4 return new RequestSpecificRetryHandler(false, false, RetryHandler.DEFAULT, null); 5 }
3、LoadBalancerCommand
看 LoadBalancerCommand 的 submit 方法,這個方法是重試的核心程式碼。
- 首先獲取了同一個Server重試次數 maxRetrysSame 和 重試下一個Server的次數 maxRetrysNext,其實就是前面配置的 ribbon.MaxAutoRetries 和 ribbon.MaxAutoRetriesNextServer,我設置的是 1。
- 然後創建了一個 Observable,它的第一層會先通過 loadBalancerContext 獲取 Server。在重試下一個 Server 時,這裡就會獲取下一個 Server。
- 在第二層,又創建了一個 Observable,這個 Observable 就是調用 ServerOperation 的,就是重構 URI,調用具體的 AbstractLoadBalancerAwareClient 執行請求。
- 在第二層里,會根據 maxRetrysSame 重試同一個 Server,從 retryPolicy 中可以了解到,當重試次數大於 maxRetrysSame 後,同一個 Server 重試就結束了,否則就用 retryHandler.isRetriableException 判斷是否重試,這個前面已經分析過了。
- 在外層,則根據 maxRetrysNext 重試不同的 Server,從 retryPolicy 中可以了解到,當不同Server重試次數大於 maxRetrysNext 後,就重試結束了,整個重試也就結束了,如果還是失敗,就會進入 onErrorResumeNext 進行最後的失敗處理。
最後來總結一下 LoadBalancerCommand 重試:
- 重試分為同一個 Server 重試和重試下一個Server,當重試次數大於設置的重試值時,就停止重試。否則通過 retryHandler.isRetriableException 判斷是否重試。
- 那這裡一共請求了多少次呢?可以總結出如下公式:請求次數 = (maxRetrysSame + 1) * (maxRetrysNext + 1),所以按 ribbon.MaxAutoRetries = 1、ribbon.MaxAutoRetriesNextServer = 1 的配置,如果每次請求都超時,就會發起 4 次請求。
1 public Observable<T> submit(final ServerOperation<T> operation) { 2 final ExecutionInfoContext context = new ExecutionInfoContext(); 3 4 // 同一個Server重試次數 5 final int maxRetrysSame = retryHandler.getMaxRetriesOnSameServer(); 6 // 重試下一個Server的次數 7 final int maxRetrysNext = retryHandler.getMaxRetriesOnNextServer(); 8 9 // 創建一個 Observable 10 Observable<T> o = 11 // 使用 loadBalancerContext 獲取 Server 12 (server == null ? selectServer() : Observable.just(server)) 13 .concatMap(new Func1<Server, Observable<T>>() { 14 @Override 15 public Observable<T> call(Server server) { 16 // 設置Server 17 context.setServer(server); 18 final ServerStats stats = loadBalancerContext.getServerStats(server); 19 20 // 創建 Observable 21 Observable<T> o = Observable 22 .just(server) 23 .concatMap(new Func1<Server, Observable<T>>() { 24 @Override 25 public Observable<T> call(final Server server) { 26 // 增加嘗試次數 27 context.incAttemptCount(); 28 // ... 29 // 調用 ServerOperation 30 return operation.call(server).doOnEach(new Observer<T>() { 31 // 一些回調方法 32 }); 33 } 34 }); 35 // 重試同一個Server 36 if (maxRetrysSame > 0) 37 o = o.retry(retryPolicy(maxRetrysSame, true)); 38 return o; 39 } 40 }); 41 42 if (maxRetrysNext > 0 && server == null) 43 // 重試不同Server 44 o = o.retry(retryPolicy(maxRetrysNext, false)); 45 46 return o.onErrorResumeNext(new Func1<Throwable, Observable<T>>() { 47 @Override 48 public Observable<T> call(Throwable e) { 49 // 異常處理 50 return Observable.error(e); 51 } 52 }); 53 } 54 55 // retryPolicy 返回一個是否重試的斷言 56 private Func2<Integer, Throwable, Boolean> retryPolicy(final int maxRetrys, final boolean same) { 57 return new Func2<Integer, Throwable, Boolean>() { 58 @Override 59 public Boolean call(Integer tryCount, Throwable e) { 60 // 請求拒絕異常就不允許重試 61 if (e instanceof AbortExecutionException) { 62 return false; 63 } 64 // 嘗試次數是否大於最大重試次數 65 if (tryCount > maxRetrys) { 66 return false; 67 } 68 // 使用 RequestSpecificRetryHandler 判斷是否重試 69 return retryHandler.isRetriableException(e, same); 70 } 71 }; 72 }
4、RetryTemplate
① spring-retry
要啟用 RetryTemplate 需先引入 spring-retry:
1 <dependency> 2 <groupId>org.springframework.retry</groupId> 3 <artifactId>spring-retry</artifactId> 4 </dependency>
以 RetryableRibbonLoadBalancingHttpClient 為例,先看看它的 execute 方法,它先創建了負載均衡重試策略類 LoadBalancedRetryPolicy,然後將請求調用的邏輯封裝到 RetryCallback 中,最後其實就是用 RetryTemplate 執行這個 RetryCallback,也就是說請求重試的邏輯都在 RetryTemplate 中。
1 public RibbonApacheHttpResponse execute(final RibbonApacheHttpRequest request, final IClientConfig configOverride) throws Exception { 2 //... 3 4 // 負載均衡重試策略 RibbonLoadBalancedRetryPolicy 5 final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory.createRetryPolicy(this.getClientName(), this); 6 7 RetryCallback<RibbonApacheHttpResponse, Exception> retryCallback = context -> { 8 // ... 9 // delegate => CloseableHttpClient 10 final HttpResponse httpResponse = RetryableRibbonLoadBalancingHttpClient.this.delegate.execute(httpUriRequest); 11 // ... 12 // 成功 返回結果 13 return new RibbonApacheHttpResponse(httpResponse, httpUriRequest.getURI()); 14 }; 15 16 LoadBalancedRecoveryCallback<RibbonApacheHttpResponse, HttpResponse> recoveryCallback = new LoadBalancedRecoveryCallback<RibbonApacheHttpResponse, HttpResponse>()//... 17 18 return this.executeWithRetry(request, retryPolicy, retryCallback, recoveryCallback); 19 } 20 21 private RibbonApacheHttpResponse executeWithRetry(RibbonApacheHttpRequest request, 22 LoadBalancedRetryPolicy retryPolicy, 23 RetryCallback<RibbonApacheHttpResponse, Exception> callback, 24 RecoveryCallback<RibbonApacheHttpResponse> recoveryCallback) 25 throws Exception { 26 RetryTemplate retryTemplate = new RetryTemplate(); 27 28 // retryable => 取自 RibbonCommandContext 設置的 retryable 參數 29 boolean retryable = isRequestRetryable(request); 30 // 設置重試策略 31 retryTemplate.setRetryPolicy(retryPolicy == null || !retryable 32 ? new NeverRetryPolicy() : new RetryPolicy(request, retryPolicy, this, this.getClientName())); 33 34 BackOffPolicy backOffPolicy = loadBalancedRetryFactory.createBackOffPolicy(this.getClientName()); 35 retryTemplate.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy); 36 37 // 利用 retryTemplate 執行請求 callback 38 return retryTemplate.execute(callback, recoveryCallback); 39 }
需要注意的是,在 executeWithRetry 中,會判斷是否要重試,判斷的邏輯中 getRetryable 其實就是取的 ApacheClientHttpRequest 中 executeInternal 方法里創建的 RibbonCommandContext 設置的 retryable 參數,這就和前面訂製化的邏輯銜接上了。
1 private boolean isRequestRetryable(ContextAwareRequest request) { 2 if (request.getContext() == null || request.getContext().getRetryable() == null) { 3 return true; 4 } 5 return request.getContext().getRetryable(); 6 }
② RetryTemplate
進入 RetryTemplate 的 execute 方法,核心的邏輯我精簡成如下程式碼,主要就是一個 while 循環判斷是否可以重試,然後調用 retryCallback 執行請求。請求失敗後,比如超時,拋出異常,就會 registerThrowable 來註冊異常。
1 protected <T, E extends Throwable> T doExecute(RetryCallback<T, E> retryCallback, 2 RecoveryCallback<T> recoveryCallback, RetryState state) throws E, ExhaustedRetryException { 3 4 // retryPolicy => InterceptorRetryPolicy 5 RetryPolicy retryPolicy = this.retryPolicy; 6 BackOffPolicy backOffPolicy = this.backOffPolicy; 7 //.... 8 try { 9 // ... 10 // canRetry 判斷是否重試 11 while (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) { 12 try { 13 // retryCallback 調用 14 return retryCallback.doWithRetry(context); 15 } 16 catch (Throwable e) { 17 // ... 18 // 註冊異常 19 registerThrowable(retryPolicy, state, context, e); 20 // ... 21 } 22 } 23 exhausted = true; 24 return handleRetryExhausted(recoveryCallback, context, state); 25 } 26 //... 27 }
看 canRetry 方法,它實際是調用了 InterceptorRetryPolicy 的 canRetry。第一次調用時,會去獲取 Server;否則就用 RibbonLoadBalancedRetryPolicy 判斷是否重試下一個 Server,注意它判斷的邏輯是 GET 請求或者允許所有操作操作重試,且 Server 重試次數 nextServerCount 小於等於配置的 MaxAutoRetriesNextServer 。也就是說,while 循環判斷的 canRetry 是重試下一個 Server 的。
1 protected boolean canRetry(RetryPolicy retryPolicy, RetryContext context) { 2 return retryPolicy.canRetry(context); 3 } 4 5 //////////// InterceptorRetryPolicy 6 public boolean canRetry(RetryContext context) { 7 LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext) context; 8 if (lbContext.getRetryCount() == 0 && lbContext.getServiceInstance() == null) { 9 // 獲取 Server 10 lbContext.setServiceInstance(this.serviceInstanceChooser.choose(this.serviceName)); 11 return true; 12 } 13 // RibbonLoadBalancedRetryPolicy => 重試下一個Server 14 return this.policy.canRetryNextServer(lbContext); 15 } 16 17 ///////// RibbonLoadBalancedRetryPolicy 18 public boolean canRetryNextServer(LoadBalancedRetryContext context) { 19 // 判斷重試下一個Server 20 return nextServerCount <= lbContext.getRetryHandler().getMaxRetriesOnNextServer() 21 && canRetry(context); 22 } 23 24 public boolean canRetry(LoadBalancedRetryContext context) { 25 // GET 請求或者允許所有操作重試時,就允許重試 26 HttpMethod method = context.getRequest().getMethod(); 27 return HttpMethod.GET == method || lbContext.isOkToRetryOnAllOperations(); 28 }
接著看請求失敗後的註冊異常 registerThrowable,它最後會向 RibbonLoadBalancedRetryPolicy 註冊異常。在 RibbonLoadBalancedRetryPolicy 的 registerThrowable 方法中,如果不重試同一個Server且可以重試下一個Server,就會輪詢獲取下一個Server。如果可以在同一個Server上重試,sameServerCount 計數器就+1,否則重置 sameServerCount,然後 nextServerCount +1。
1 protected void registerThrowable(RetryPolicy retryPolicy, RetryState state, 2 RetryContext context, Throwable e) { 3 retryPolicy.registerThrowable(context, e); 4 registerContext(context, state); 5 } 6 7 ///////// InterceptorRetryPolicy ///////// 8 public void registerThrowable(RetryContext context, Throwable throwable) { 9 LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext) context; 10 lbContext.registerThrowable(throwable); 11 // RibbonLoadBalancedRetryPolicy 12 this.policy.registerThrowable(lbContext, throwable); 13 } 14 15 ///////// RibbonLoadBalancedRetryPolicy ///////// 16 public void registerThrowable(LoadBalancedRetryContext context, Throwable throwable) { 17 //... 18 // 如果不在在同一個Server 上重試且可以重試下一個Server,則重新選擇一個 Server 19 if (!canRetrySameServer(context) && canRetryNextServer(context)) { 20 context.setServiceInstance(loadBalanceChooser.choose(serviceId)); 21 } 22 23 // 同一個Server重試超過設置的值後,就重置 sameServerCount 24 if (sameServerCount >= lbContext.getRetryHandler().getMaxRetriesOnSameServer() 25 && canRetry(context)) { 26 // 重置 nextServerCount 27 sameServerCount = 0; 28 // 下一個Server重試次數+1 29 nextServerCount++; 30 if (!canRetryNextServer(context)) { 31 // 不能重試下一個Server了 32 context.setExhaustedOnly(); 33 } 34 } 35 else { 36 // 同一個Server重試次數+1 37 sameServerCount++; 38 } 39 } 40 41 // 判斷是否重試同一個Server 42 public boolean canRetrySameServer(LoadBalancedRetryContext context) { 43 return sameServerCount < lbContext.getRetryHandler().getMaxRetriesOnSameServer() 44 && canRetry(context); 45 } 46 47 public boolean canRetry(LoadBalancedRetryContext context) { 48 // GET 請求或者允許所有操作重試時,就允許重試 49 HttpMethod method = context.getRequest().getMethod(); 50 return HttpMethod.GET == method || lbContext.isOkToRetryOnAllOperations(); 51 }
5、Ribbon 重試總結
① 首先,Ribbon 關於超時和重試的配置參數如下,這些參數也可以針對某個客戶端配置:
1 ribbon: 2 # 客戶端讀取超時時間 3 ReadTimeout: 1000 4 # 客戶端連接超時時間 5 ConnectTimeout: 1000 6 # 默認只重試 GET,設置為 true 時將重試所有類型,如 POST、PUT、DELETE 7 OkToRetryOnAllOperations: false 8 # 同一個Server重試次數 9 MaxAutoRetries: 1 10 # 最多重試幾個Server 11 MaxAutoRetriesNextServer: 1
② RetryTemplate 是 spring-retry 的重試組件,LoadBalancerCommand 是 Ribbon 的重試組件。它們重試的請求次數是一樣的,重試邏輯也是類似,都是先重試當前 Server,再重試下一個Server,總的請求次數 = (MaxAutoRetries + 1) * (MaxAutoRetriesNextServer + 1)。
③ 但是有點差別的是,RetryTemplate 會判斷請求方法為 GET 或者 OkToRetryOnAllOperations=true 時才允許重試,而 LoadBalancerCommand 是所有 http 方法都可以重試。這個其實是有問題的,一般只有GET才允許重試,因為GET是查詢操作,介面是冪等的,而POST、PUT、DELETE一般是非冪等的。所以一般更建議使用 RetryTemplate,並且配置 OkToRetryOnAllOperations=false。
④ 為了提升服務間通訊性能,一般可以啟用 apache httpclient 或者 OkHttp,如果要啟用重試功能,還需要引入 spring-retry 依賴。重試時,當前Server就不要重試了(MaxAutoRetries=0),直接重試下一個Server。
1 ribbon: 2 # 客戶端讀取超時時間 3 ReadTimeout: 1000 4 # 客戶端連接超時時間 5 ConnectTimeout: 1000 6 # 默認只重試 GET,設置為 true 時將重試所有類型,如 POST、PUT、DELETE 7 OkToRetryOnAllOperations: false 8 # 同一個Server重試次數 9 MaxAutoRetries: 0 10 # 最多重試幾個Server 11 MaxAutoRetriesNextServer: 1 12 # 啟用 httpclient 13 httpclient: 14 enabled: false 15 # 啟用 RestClient 16 restclient: 17 enabled: false 18 # 啟用 okhttp 19 okhttp: 20 enabled: true