001// *************************************************************************************************************************** 002// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * 003// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * 004// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * 005// * with the License. You may obtain a copy of the License at * 006// * * 007// * http://www.apache.org/licenses/LICENSE-2.0 * 008// * * 009// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * 010// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * 011// * specific language governing permissions and limitations under the License. * 012// *************************************************************************************************************************** 013package org.apache.juneau.rest.client; 014 015import static org.apache.juneau.internal.StringUtils.*; 016import static org.apache.juneau.parser.InputStreamParser.*; 017import static org.apache.juneau.parser.ReaderParser.*; 018import static org.apache.juneau.rest.client.RestClient.*; 019import static org.apache.juneau.BeanTraverseContext.*; 020import static org.apache.juneau.serializer.OutputStreamSerializer.*; 021import static org.apache.juneau.serializer.WriterSerializer.*; 022import static org.apache.juneau.uon.UonSerializer.*; 023 024import java.lang.reflect.*; 025import java.net.*; 026import java.net.URI; 027import java.security.*; 028import java.util.*; 029import java.util.concurrent.*; 030import java.util.logging.*; 031 032import javax.net.ssl.*; 033 034import org.apache.http.*; 035import org.apache.http.auth.*; 036import org.apache.http.client.*; 037import org.apache.http.client.CookieStore; 038import org.apache.http.client.config.*; 039import org.apache.http.client.entity.*; 040import org.apache.http.config.*; 041import org.apache.http.conn.*; 042import org.apache.http.conn.routing.*; 043import org.apache.http.conn.socket.*; 044import org.apache.http.conn.ssl.*; 045import org.apache.http.conn.util.*; 046import org.apache.http.cookie.*; 047import org.apache.http.impl.client.*; 048import org.apache.http.impl.conn.*; 049import org.apache.http.protocol.*; 050import org.apache.juneau.*; 051import org.apache.juneau.html.*; 052import org.apache.juneau.http.*; 053import org.apache.juneau.httppart.*; 054import org.apache.juneau.internal.*; 055import org.apache.juneau.json.*; 056import org.apache.juneau.marshall.*; 057import org.apache.juneau.msgpack.*; 058import org.apache.juneau.oapi.*; 059import org.apache.juneau.parser.*; 060import org.apache.juneau.plaintext.*; 061import org.apache.juneau.reflect.*; 062import org.apache.juneau.serializer.*; 063import org.apache.juneau.svl.*; 064import org.apache.juneau.uon.*; 065import org.apache.juneau.urlencoding.*; 066import org.apache.juneau.xml.*; 067 068/** 069 * Builder class for the {@link RestClient} class. 070 * 071 * <p> 072 * Instances of this class are created by the following methods: 073 * <ul> 074 * <li>{@link RestClient#create()} - Create from scratch. 075 * <li>{@link RestClient#create(Serializer,Parser)} - Create from scratch using specified serializer/parser. 076 * <li>{@link RestClient#create(Class,Class)} - Create from scratch using specified serializer/parser classes. 077 * <li>{@link RestClient#builder()} - Copy settings from an existing client. 078 * </ul> 079 * 080 * <ul class='seealso'> 081 * <li class='link'>{@doc juneau-rest-client} 082 * </ul> 083 */ 084public class RestClientBuilder extends BeanContextBuilder { 085 086 private HttpClientBuilder httpClientBuilder; 087 private CloseableHttpClient httpClient; 088 089 // Deprecated 090 @Deprecated private HttpClientConnectionManager httpClientConnectionManager; 091 @Deprecated private boolean enableSsl = false; 092 @Deprecated private HostnameVerifier hostnameVerifier; 093 @Deprecated private KeyManager[] keyManagers; 094 @Deprecated private TrustManager[] trustManagers; 095 @Deprecated private SecureRandom secureRandom; 096 @Deprecated private String[] sslProtocols, cipherSuites; 097 @Deprecated private boolean pooled; 098 099 /** 100 * Constructor. 101 * @param ps 102 * Initial configuration properties for this builder. 103 * <br>Can be <jk>null</jk>. 104 * @param httpClientBuilder 105 * The HTTP client builder to use for this REST client builder. 106 * <br>Can be <jk>null</jk> to just call {@link #createHttpClientBuilder()} to instantiate it again. 107 */ 108 protected RestClientBuilder(PropertyStore ps, HttpClientBuilder httpClientBuilder) { 109 super(ps); 110 this.httpClientBuilder = httpClientBuilder != null ? httpClientBuilder : createHttpClientBuilder(); 111 } 112 113 @Override /* ContextBuilder */ 114 public RestClient build() { 115 return new RestClient(this); 116 } 117 118 //------------------------------------------------------------------------------------------------------------------ 119 // Convenience marshalling support methods. 120 //------------------------------------------------------------------------------------------------------------------ 121 122 /** 123 * Convenience method for specifying JSON as the transmission media type. 124 * 125 * <p> 126 * Identical to calling <code>serializer(JsonSerializer.<jk>class</jk>).parser(JsonParser.<jk>class</jk>)</code>. 127 * 128 * @return This object (for method chaining). 129 */ 130 public RestClientBuilder json() { 131 return serializer(JsonSerializer.class).parser(JsonParser.class); 132 } 133 134 /** 135 * Convenience method for specifying Simple JSON as the transmission media type. 136 * 137 * <p> 138 * Identical to calling <code>serializer(SimpleJsonSerializer.<jk>class</jk>).parser(JsonParser.<jk>class</jk>)</code>. 139 * 140 * @return This object (for method chaining). 141 */ 142 public RestClientBuilder simpleJson() { 143 return serializer(SimpleJsonSerializer.class).parser(JsonParser.class); 144 } 145 146 /** 147 * Convenience method for specifying XML as the transmission media type. 148 * 149 * <p> 150 * Identical to calling <code>serializer(XmlSerializer.<jk>class</jk>).parser(XmlParser.<jk>class</jk>)</code>. 151 * 152 * @return This object (for method chaining). 153 */ 154 public RestClientBuilder xml() { 155 return serializer(XmlSerializer.class).parser(XmlParser.class); 156 } 157 158 /** 159 * Convenience method for specifying HTML as the transmission media type. 160 * 161 * <p> 162 * Identical to calling <code>serializer(HtmlSerializer.<jk>class</jk>).parser(HtmlParser.<jk>class</jk>)</code>. 163 * 164 * @return This object (for method chaining). 165 */ 166 public RestClientBuilder html() { 167 return serializer(HtmlSerializer.class).parser(HtmlParser.class); 168 } 169 170 /** 171 * Convenience method for specifying plain-text as the transmission media type. 172 * 173 * <p> 174 * Identical to calling <code>serializer(PlainTextSerializer.<jk>class</jk>).parser(PlainTextParser.<jk>class</jk>)</code>. 175 * 176 * @return This object (for method chaining). 177 */ 178 public RestClientBuilder plainText() { 179 return serializer(PlainTextSerializer.class).parser(PlainTextParser.class); 180 } 181 182 /** 183 * Convenience method for specifying MessagePack as the transmission media type. 184 * 185 * <p> 186 * Identical to calling <code>serializer(MsgPackSerializer.<jk>class</jk>).parser(MsgPackParser.<jk>class</jk>)</code>. 187 * 188 * @return This object (for method chaining). 189 */ 190 public RestClientBuilder msgpack() { 191 return serializer(MsgPackSerializer.class).parser(MsgPackParser.class); 192 } 193 194 /** 195 * Convenience method for specifying UON as the transmission media type. 196 * 197 * <p> 198 * Identical to calling <code>serializer(UonSerializer.<jk>class</jk>).parser(UonParser.<jk>class</jk>)</code>. 199 * 200 * @return This object (for method chaining). 201 */ 202 public RestClientBuilder uon() { 203 return serializer(UonSerializer.class).parser(UonParser.class); 204 } 205 206 /** 207 * Convenience method for specifying URL-Encoding as the transmission media type. 208 * 209 * <p> 210 * Identical to calling <code>serializer(UrlEncodingSerializer.<jk>class</jk>).parser(UrlEncodingParser.<jk>class</jk>)</code>. 211 * 212 * @return This object (for method chaining). 213 */ 214 public RestClientBuilder urlEnc() { 215 return serializer(UrlEncodingSerializer.class).parser(UrlEncodingParser.class); 216 } 217 218 /** 219 * Convenience method for specifying URL-Encoding as the transmission media type. 220 * 221 * <p> 222 * Identical to calling <code>serializer(OpenApiSerializer.<jk>class</jk>).parser(OpenApiParser.<jk>class</jk>)</code>. 223 * 224 * @return This object (for method chaining). 225 */ 226 public RestClientBuilder openapi() { 227 return serializer(OpenApiSerializer.class).parser(OpenApiParser.class); 228 } 229 230 //------------------------------------------------------------------------------------------------------------------ 231 // HttpClientBuilder 232 //------------------------------------------------------------------------------------------------------------------ 233 234 /** 235 * Creates an instance of an {@link HttpClientBuilder} to be used to create the {@link HttpClient}. 236 * 237 * <p> 238 * Subclasses can override this method to provide their own client builder. 239 * The builder can also be specified using the {@link #httpClientBuilder(HttpClientBuilder)} method. 240 * 241 * <p> 242 * The predefined method returns an {@link HttpClientBuilder} with the following settings: 243 * <ul> 244 * <li>Lax redirect strategy. 245 * </ul> 246 * 247 * @return The HTTP client builder to use to create the HTTP client. 248 */ 249 protected HttpClientBuilder createHttpClientBuilder() { 250 return HttpClientBuilder.create().setRedirectStrategy(new AllowAllRedirects()); 251 } 252 253 /** 254 * Returns the {@link HttpClientBuilder} that will be used to create the {@link HttpClient} used by {@link RestClient}. 255 * 256 * <p> 257 * This method can be used to make customizations to the {@link HttpClient}. 258 * 259 * <p> 260 * If not set via {@link #httpClientBuilder(HttpClientBuilder)}, then this object is the one created by {@link #createHttpClientBuilder()}. 261 * 262 * @return The {@link HttpClientBuilder} that will be used to create the {@link HttpClient} used by {@link RestClient}. 263 */ 264 public HttpClientBuilder getHttpClientBuilder() { 265 if (httpClientBuilder == null) 266 httpClientBuilder = createHttpClientBuilder(); 267 return httpClientBuilder; 268 } 269 270 /** 271 * Sets the {@link HttpClientBuilder} that will be used to create the {@link HttpClient} used by {@link RestClient}. 272 * 273 * <p> 274 * This can be used to bypass the builder created by {@link #createHttpClientBuilder()} method. 275 * 276 * @param value The {@link HttpClientBuilder} that will be used to create the {@link HttpClient} used by {@link RestClient}. 277 * @return This object (for method chaining). 278 */ 279 public RestClientBuilder httpClientBuilder(HttpClientBuilder value) { 280 this.httpClientBuilder = value; 281 return this; 282 } 283 284 //------------------------------------------------------------------------------------------------------------------ 285 // HttpClient 286 //------------------------------------------------------------------------------------------------------------------ 287 288 /** 289 * Creates an instance of an {@link HttpClient} to be used to handle all HTTP communications with the target server. 290 * 291 * <p> 292 * This HTTP client is used when the HTTP client is not specified through one of the constructors or the 293 * {@link #httpClient(CloseableHttpClient, boolean)} method. 294 * 295 * <p> 296 * Subclasses can override this method to provide specially-configured HTTP clients to handle stuff such as 297 * SSL/TLS certificate handling, authentication, etc. 298 * 299 * <p> 300 * The default implementation returns an instance of {@link HttpClient} using the client builder returned by 301 * {@link #createHttpClientBuilder()}. 302 * 303 * @return The HTTP client to use. 304 * @throws Exception Error occurred. 305 */ 306 protected CloseableHttpClient createHttpClient() throws Exception { 307 // Don't call createConnectionManager() if RestClient.setConnectionManager() was called. 308 if (httpClientConnectionManager == null) 309 httpClientBuilder.setConnectionManager(createConnectionManager()); 310 else 311 httpClientBuilder.setConnectionManager(httpClientConnectionManager); 312 return httpClientBuilder.build(); 313 } 314 315 /** 316 * Returns the {@link HttpClient} to be used to handle all HTTP communications with the target server. 317 * 318 * @return The {@link HttpClient} to be used to handle all HTTP communications with the target server. 319 */ 320 public CloseableHttpClient getHttpClient() { 321 try { 322 return httpClient != null ? httpClient : createHttpClient(); 323 } catch (Exception e) { 324 throw new RuntimeException(e); 325 } 326 } 327 328 /** 329 * Sets the {@link HttpClient} to be used to handle all HTTP communications with the target server. 330 * 331 * <p> 332 * This can be used to bypass the client created by {@link #createHttpClient()} method. 333 * 334 * @param value The {@link HttpClient} to be used to handle all HTTP communications with the target server. 335 * @return This object (for method chaining). 336 */ 337 public RestClientBuilder httpClient(CloseableHttpClient value) { 338 this.httpClient = value; 339 return this; 340 } 341 342 /** 343 * Sets the internal {@link HttpClient} to use for handling HTTP communications. 344 * 345 * @param httpClient The HTTP client. 346 * @param keepHttpClientOpen Don't close this client when the {@link RestClient#close()} method is called. 347 * @return This object (for method chaining). 348 * @deprecated Use {@link #httpClient(CloseableHttpClient)} and {@link #keepHttpClientOpen(boolean)}. 349 */ 350 @Deprecated 351 public RestClientBuilder httpClient(CloseableHttpClient httpClient, boolean keepHttpClientOpen) { 352 this.httpClient = httpClient; 353 set(RESTCLIENT_keepHttpClientOpen, keepHttpClientOpen); 354 return this; 355 } 356 357 //------------------------------------------------------------------------------------------------------------------ 358 // Logging. 359 //------------------------------------------------------------------------------------------------------------------ 360 361 /** 362 * Adds a {@link RestCallLogger} to the list of interceptors on this class. 363 * 364 * @param level The log level to log messages at. 365 * @param log The logger to log messages to. 366 * @return This object (for method chaining). 367 */ 368 public RestClientBuilder logTo(Level level, Logger log) { 369 return interceptors(new RestCallLogger(level, log)); 370 } 371 372 /** 373 * Sets the internal {@link HttpClientConnectionManager}. 374 * 375 * @param httpClientConnectionManager The HTTP client connection manager. 376 * @return This object (for method chaining). 377 */ 378 public RestClientBuilder httpClientConnectionManager(HttpClientConnectionManager httpClientConnectionManager) { 379 this.httpClientConnectionManager = httpClientConnectionManager; 380 return this; 381 } 382 383 //------------------------------------------------------------------------------------------------------------------ 384 // Deprecated HttpClientBuilder methods. 385 //------------------------------------------------------------------------------------------------------------------ 386 387 /** 388 * Creates the {@link HttpClientConnectionManager} returned by {@link #createConnectionManager()}. 389 * 390 * <p> 391 * Subclasses can override this method to provide their own connection manager. 392 * 393 * <p> 394 * The default implementation returns an instance of a {@link PoolingHttpClientConnectionManager}. 395 * 396 * @return The HTTP client builder to use to create the HTTP client. 397 * @throws NoSuchAlgorithmException Unknown cryptographic algorithm. 398 * @throws KeyManagementException General key management exception. 399 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 400 */ 401 @SuppressWarnings("resource") 402 @Deprecated 403 protected HttpClientConnectionManager createConnectionManager() throws KeyManagementException, NoSuchAlgorithmException { 404 if (enableSsl) { 405 406 HostnameVerifier hv = hostnameVerifier != null ? hostnameVerifier : new DefaultHostnameVerifier(); 407 TrustManager[] tm = trustManagers; 408 String[] sslp = sslProtocols == null ? getDefaultProtocols() : sslProtocols; 409 SecureRandom sr = secureRandom; 410 KeyManager[] km = keyManagers; 411 String[] cs = cipherSuites; 412 413 RegistryBuilder<ConnectionSocketFactory> rb = RegistryBuilder.<ConnectionSocketFactory>create(); 414 rb.register("http", PlainConnectionSocketFactory.getSocketFactory()); 415 416 SSLContext sslContext = org.apache.http.ssl.SSLContexts.custom().build(); 417 sslContext.init(km, tm, sr); 418 419 SSLConnectionSocketFactory sslcsf = new SSLConnectionSocketFactory(sslContext, sslp, cs, hv); 420 rb.register("https", sslcsf).build(); 421 422 return (pooled ? new PoolingHttpClientConnectionManager(rb.build()) : new BasicHttpClientConnectionManager(rb.build())); 423 } 424 425 // Using pooling connection so that this client is threadsafe. 426 return (pooled ? new PoolingHttpClientConnectionManager() : new BasicHttpClientConnectionManager()); 427 } 428 429 private static String[] getDefaultProtocols() { 430 String sp = System.getProperty("transport.client.protocol"); 431 if (isEmpty(sp)) 432 return new String[] {"SSL_TLS","TLS","SSL"}; 433 return StringUtils.split(sp, ','); 434 } 435 436 /** 437 * Enable SSL support on this client. 438 * 439 * <p> 440 * Used in conjunction with the following methods for setting up SSL parameters: 441 * <ul class='javatree'> 442 * <li class='jf'>{@link #sslProtocols(String...)} 443 * <li class='jf'>{@link #cipherSuites(String...)} 444 * <li class='jf'>{@link #hostnameVerifier(HostnameVerifier)} 445 * <li class='jf'>{@link #keyManagers(KeyManager...)} 446 * <li class='jf'>{@link #trustManagers(TrustManager...)} 447 * <li class='jf'>{@link #secureRandom(SecureRandom)} 448 * </ul> 449 * 450 * @return This object (for method chaining). 451 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 452 */ 453 @Deprecated 454 public RestClientBuilder enableSSL() { 455 this.enableSsl = true; 456 return this; 457 } 458 459 /** 460 * Enable LARestClientBuilder SSL support. 461 * 462 * <p> 463 * Same as calling the following: 464 * <p class='bcode w800'> 465 * builder 466 * .enableSSL() 467 * .hostnameVerifier(<jk>new</jk> NoopHostnameVerifier()) 468 * .trustManagers(<jk>new</jk> SimpleX509TrustManager(<jk>true</jk>)); 469 * </p> 470 * 471 * @return This object (for method chaining). 472 * @throws KeyStoreException Generic keystore exception. 473 * @throws NoSuchAlgorithmException Unknown cryptographic algorithm. 474 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 475 */ 476 @Deprecated 477 public RestClientBuilder enableLaxSSL() throws KeyStoreException, NoSuchAlgorithmException { 478 this.enableSsl = true; 479 hostnameVerifier(new NoopHostnameVerifier()); 480 trustManagers(new SimpleX509TrustManager(true)); 481 return this; 482 } 483 484 /** 485 * Supported SSL protocols. 486 * 487 * <p> 488 * This is the value passed to the <c>supportedProtocols</c> parameter of the 489 * {@link SSLConnectionSocketFactory#SSLConnectionSocketFactory(SSLContext,String[],String[],HostnameVerifier)} 490 * constructor. 491 * 492 * <p> 493 * The default value is taken from the system property <js>"transport.client.protocol"</js>. 494 * <br>If system property is not defined, defaults to <code>{<js>"SSL_TLS"</js>,<js>"TLS"</js>,<js>"SSL"</js>}</code>. 495 * 496 * <p> 497 * This method is effectively ignored if {@link #enableSSL()} has not been called or the client connection manager 498 * has been defined via {@link #httpClientConnectionManager(HttpClientConnectionManager)}. 499 * 500 * @param sslProtocols The supported SSL protocols. 501 * @return This object (for method chaining). 502 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 503 */ 504 @Deprecated 505 public RestClientBuilder sslProtocols(String...sslProtocols) { 506 this.sslProtocols = sslProtocols; 507 return this; 508 } 509 510 /** 511 * Supported cipher suites. 512 * 513 * <p> 514 * This is the value passed to the <c>supportedCipherSuites</c> parameter of the 515 * {@link SSLConnectionSocketFactory#SSLConnectionSocketFactory(SSLContext,String[],String[],HostnameVerifier)} 516 * constructor. 517 * 518 * <p> 519 * The default value is <jk>null</jk>. 520 * 521 * <p> 522 * This method is effectively ignored if {@link #enableSSL()} has not been called or the client connection manager 523 * has been defined via {@link #httpClientConnectionManager(HttpClientConnectionManager)}. 524 * 525 * @param cipherSuites The supported cipher suites. 526 * @return This object (for method chaining). 527 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 528 */ 529 @Deprecated 530 public RestClientBuilder cipherSuites(String...cipherSuites) { 531 this.cipherSuites = cipherSuites; 532 return this; 533 } 534 535 /** 536 * Hostname verifier. 537 * 538 * <p> 539 * This is the value passed to the <c>hostnameVerifier</c> parameter of the 540 * {@link SSLConnectionSocketFactory#SSLConnectionSocketFactory(SSLContext,String[],String[],HostnameVerifier)} 541 * constructor. 542 * 543 * <p> 544 * The default value is <jk>null</jk>. 545 * 546 * <p> 547 * This method is effectively ignored if {@link #enableSSL()} has not been called or the client connection manager 548 * has been defined via {@link #httpClientConnectionManager(HttpClientConnectionManager)}. 549 * 550 * @param hostnameVerifier The hostname verifier. 551 * @return This object (for method chaining). 552 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 553 */ 554 @Deprecated 555 public RestClientBuilder hostnameVerifier(HostnameVerifier hostnameVerifier) { 556 this.hostnameVerifier = hostnameVerifier; 557 return this; 558 } 559 560 /** 561 * Key managers. 562 * 563 * <p> 564 * This is the value passed to the <c>keyManagers</c> parameter of the 565 * {@link SSLContext#init(KeyManager[],TrustManager[],SecureRandom)} method. 566 * 567 * <p> 568 * The default value is <jk>null</jk>. 569 * 570 * <p> 571 * This method is effectively ignored if {@link #enableSSL()} has not been called or the client connection manager 572 * has been defined via {@link #httpClientConnectionManager(HttpClientConnectionManager)}. 573 * 574 * @param keyManagers The key managers. 575 * @return This object (for method chaining). 576 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 577 */ 578 @Deprecated 579 public RestClientBuilder keyManagers(KeyManager...keyManagers) { 580 this.keyManagers = keyManagers; 581 return this; 582 } 583 584 /** 585 * Trust managers. 586 * 587 * <p> 588 * This is the value passed to the <c>trustManagers</c> parameter of the 589 * {@link SSLContext#init(KeyManager[],TrustManager[],SecureRandom)} method. 590 * 591 * <p> 592 * The default value is <jk>null</jk>. 593 * 594 * <p> 595 * This method is effectively ignored if {@link #enableSSL()} has not been called or the client connection manager 596 * has been defined via {@link #httpClientConnectionManager(HttpClientConnectionManager)}. 597 * 598 * @param trustManagers The trust managers. 599 * @return This object (for method chaining). 600 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 601 */ 602 @Deprecated 603 public RestClientBuilder trustManagers(TrustManager...trustManagers) { 604 this.trustManagers = trustManagers; 605 return this; 606 } 607 608 /** 609 * Trust managers. 610 * 611 * <p> 612 * This is the value passed to the <c>random</c> parameter of the 613 * {@link SSLContext#init(KeyManager[],TrustManager[],SecureRandom)} method. 614 * 615 * <p> 616 * The default value is <jk>null</jk>. 617 * 618 * <p> 619 * This method is effectively ignored if {@link #enableSSL()} has not been called or the client connection manager 620 * has been defined via {@link #httpClientConnectionManager(HttpClientConnectionManager)}. 621 * 622 * @param secureRandom The random number generator. 623 * @return This object (for method chaining). 624 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 625 */ 626 @Deprecated 627 public RestClientBuilder secureRandom(SecureRandom secureRandom) { 628 this.secureRandom = secureRandom; 629 return this; 630 } 631 632 /** 633 * When called, the {@link #createConnectionManager()} method will return a {@link PoolingHttpClientConnectionManager} 634 * instead of a {@link BasicHttpClientConnectionManager}. 635 * 636 * @return This object (for method chaining). 637 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 638 */ 639 @Deprecated 640 public RestClientBuilder pooled() { 641 this.pooled = true; 642 return this; 643 } 644 645 /** 646 * Set up this client to use BASIC auth. 647 * 648 * @param host The auth scope hostname. 649 * @param port The auth scope port. 650 * @param user The username. 651 * @param pw The password. 652 * @return This object (for method chaining). 653 * @deprecated Use {@link #getHttpClientBuilder()} and modify the client builder directly using {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 654 */ 655 @Deprecated 656 public RestClientBuilder basicAuth(String host, int port, String user, String pw) { 657 AuthScope scope = new AuthScope(host, port); 658 Credentials up = new UsernamePasswordCredentials(user, pw); 659 CredentialsProvider p = new BasicCredentialsProvider(); 660 p.setCredentials(scope, up); 661 defaultCredentialsProvider(p); 662 return this; 663 } 664 665 //----------------------------------------------------------------------------------------------------------------- 666 // HTTP headers 667 //----------------------------------------------------------------------------------------------------------------- 668 669 /** 670 * Sets arbitrary request headers. 671 * 672 * @param headers The headers to set on requests. 673 * @return This object (for method chaining). 674 */ 675 public RestClientBuilder headers(Map<String,Object> headers) { 676 if (headers != null) 677 for (Map.Entry<String,Object> e : headers.entrySet()) 678 header(e.getKey(), e.getValue()); 679 return this; 680 } 681 682 /** 683 * Sets the value for the <c>Accept</c> request header. 684 * 685 * <p> 686 * This overrides the media type specified on the parser, but is overridden by calling 687 * <code>header(<js>"Accept"</js>, value);</code> 688 * 689 * @param value The new header value. 690 * @return This object (for method chaining). 691 */ 692 public RestClientBuilder accept(Object value) { 693 return header("Accept", value); 694 } 695 696 /** 697 * Sets the value for the <c>Accept-Charset</c> request header. 698 * 699 * <p> 700 * This is a shortcut for calling <code>header(<js>"Accept-Charset"</js>, value);</code> 701 * 702 * @param value The new header value. 703 * @return This object (for method chaining). 704 */ 705 public RestClientBuilder acceptCharset(Object value) { 706 return header("Accept-Charset", value); 707 } 708 709 /** 710 * Sets the value for the <c>Accept-Encoding</c> request header. 711 * 712 * <p> 713 * This is a shortcut for calling <code>header(<js>"Accept-Encoding"</js>, value);</code> 714 * 715 * @param value The new header value. 716 * @return This object (for method chaining). 717 */ 718 public RestClientBuilder acceptEncoding(Object value) { 719 return header("Accept-Encoding", value); 720 } 721 722 /** 723 * Sets the value for the <c>Accept-Language</c> request header. 724 * 725 * <p> 726 * This is a shortcut for calling <code>header(<js>"Accept-Language"</js>, value);</code> 727 * 728 * @param value The new header value. 729 * @return This object (for method chaining). 730 */ 731 public RestClientBuilder acceptLanguage(Object value) { 732 return header("Accept-Language", value); 733 } 734 735 /** 736 * Sets the value for the <c>Authorization</c> request header. 737 * 738 * <p> 739 * This is a shortcut for calling <code>header(<js>"Authorization"</js>, value);</code> 740 * 741 * @param value The new header value. 742 * @return This object (for method chaining). 743 */ 744 public RestClientBuilder authorization(Object value) { 745 return header("Authorization", value); 746 } 747 748 /** 749 * Sets the value for the <c>Cache-Control</c> request header. 750 * 751 * <p> 752 * This is a shortcut for calling <code>header(<js>"Cache-Control"</js>, value);</code> 753 * 754 * @param value The new header value. 755 * @return This object (for method chaining). 756 */ 757 public RestClientBuilder cacheControl(Object value) { 758 return header("Cache-Control", value); 759 } 760 761 /** 762 * Sets the client version by setting the value for the <js>"X-Client-Version"</js> header. 763 * 764 * @param version The version string (e.g. <js>"1.2.3"</js>) 765 * @return This object (for method chaining). 766 */ 767 public RestClientBuilder clientVersion(String version) { 768 return header("X-Client-Version", version); 769 } 770 771 /** 772 * Sets the value for the <c>Connection</c> request header. 773 * 774 * <p> 775 * This is a shortcut for calling <code>header(<js>"Connection"</js>, value);</code> 776 * 777 * @param value The new header value. 778 * @return This object (for method chaining). 779 */ 780 public RestClientBuilder connection(Object value) { 781 return header("Connection", value); 782 } 783 784 /** 785 * Sets the value for the <c>Content-Length</c> request header. 786 * 787 * <p> 788 * This is a shortcut for calling <code>header(<js>"Content-Length"</js>, value);</code> 789 * 790 * @param value The new header value. 791 * @return This object (for method chaining). 792 */ 793 public RestClientBuilder contentLength(Object value) { 794 return header("Content-Length", value); 795 } 796 797 /** 798 * Sets the value for the <c>Content-Type</c> request header. 799 * 800 * <p> 801 * This overrides the media type specified on the serializer, but is overridden by calling 802 * <code>header(<js>"Content-Type"</js>, value);</code> 803 * 804 * @param value The new header value. 805 * @return This object (for method chaining). 806 */ 807 public RestClientBuilder contentType(Object value) { 808 return header("Content-Type", value); 809 } 810 811 /** 812 * Sets the value for the <c>Date</c> request header. 813 * 814 * <p> 815 * This is a shortcut for calling <code>header(<js>"Date"</js>, value);</code> 816 * 817 * @param value The new header value. 818 * @return This object (for method chaining). 819 */ 820 public RestClientBuilder date(Object value) { 821 return header("Date", value); 822 } 823 824 /** 825 * Sets the value for the <c>Expect</c> request header. 826 * 827 * <p> 828 * This is a shortcut for calling <code>header(<js>"Expect"</js>, value);</code> 829 * 830 * @param value The new header value. 831 * @return This object (for method chaining). 832 */ 833 public RestClientBuilder expect(Object value) { 834 return header("Expect", value); 835 } 836 837 /** 838 * Sets the value for the <c>Forwarded</c> request header. 839 * 840 * <p> 841 * This is a shortcut for calling <code>header(<js>"Forwarded"</js>, value);</code> 842 * 843 * @param value The new header value. 844 * @return This object (for method chaining). 845 */ 846 public RestClientBuilder forwarded(Object value) { 847 return header("Forwarded", value); 848 } 849 850 /** 851 * Sets the value for the <c>From</c> request header. 852 * 853 * <p> 854 * This is a shortcut for calling <code>header(<js>"From"</js>, value);</code> 855 * 856 * @param value The new header value. 857 * @return This object (for method chaining). 858 */ 859 public RestClientBuilder from(Object value) { 860 return header("From", value); 861 } 862 863 /** 864 * Sets the value for the <c>Host</c> request header. 865 * 866 * <p> 867 * This is a shortcut for calling <code>header(<js>"Host"</js>, value);</code> 868 * 869 * @param value The new header value. 870 * @return This object (for method chaining). 871 */ 872 public RestClientBuilder host(Object value) { 873 return header("Host", value); 874 } 875 876 /** 877 * Sets the value for the <c>If-Match</c> request header. 878 * 879 * <p> 880 * This is a shortcut for calling <code>header(<js>"If-Match"</js>, value);</code> 881 * 882 * @param value The new header value. 883 * @return This object (for method chaining). 884 */ 885 public RestClientBuilder ifMatch(Object value) { 886 return header("If-Match", value); 887 } 888 889 /** 890 * Sets the value for the <c>If-Modified-Since</c> request header. 891 * 892 * <p> 893 * This is a shortcut for calling <code>header(<js>"If-Modified-Since"</js>, value);</code> 894 * 895 * @param value The new header value. 896 * @return This object (for method chaining). 897 */ 898 public RestClientBuilder ifModifiedSince(Object value) { 899 return header("If-Modified-Since", value); 900 } 901 902 /** 903 * Sets the value for the <c>If-None-Match</c> request header. 904 * 905 * <p> 906 * This is a shortcut for calling <code>header(<js>"If-None-Match"</js>, value);</code> 907 * 908 * @param value The new header value. 909 * @return This object (for method chaining). 910 */ 911 public RestClientBuilder ifNoneMatch(Object value) { 912 return header("If-None-Match", value); 913 } 914 915 /** 916 * Sets the value for the <c>If-Range</c> request header. 917 * 918 * <p> 919 * This is a shortcut for calling <code>header(<js>"If-Range"</js>, value);</code> 920 * 921 * @param value The new header value. 922 * @return This object (for method chaining). 923 */ 924 public RestClientBuilder ifRange(Object value) { 925 return header("If-Range", value); 926 } 927 928 /** 929 * Sets the value for the <c>If-Unmodified-Since</c> request header. 930 * 931 * <p> 932 * This is a shortcut for calling <code>header(<js>"If-Unmodified-Since"</js>, value);</code> 933 * 934 * @param value The new header value. 935 * @return This object (for method chaining). 936 */ 937 public RestClientBuilder ifUnmodifiedSince(Object value) { 938 return header("If-Unmodified-Since", value); 939 } 940 941 /** 942 * Sets the value for the <c>Max-Forwards</c> request header. 943 * 944 * <p> 945 * This is a shortcut for calling <code>header(<js>"Max-Forwards"</js>, value);</code> 946 * 947 * @param value The new header value. 948 * @return This object (for method chaining). 949 */ 950 public RestClientBuilder maxForwards(Object value) { 951 return header("If-Unmodified-Since", value); 952 } 953 954 /** 955 * When called, <c>No-Trace: true</c> is added to requests. 956 * 957 * <p> 958 * This gives the opportunity for the servlet to not log errors on invalid requests. 959 * This is useful for testing purposes when you don't want your log file to show lots of errors that are simply the 960 * results of testing. 961 * 962 * @return This object (for method chaining). 963 */ 964 public RestClientBuilder noTrace() { 965 return header("No-Trace", true); 966 } 967 968 /** 969 * Sets the value for the <c>Origin</c> request header. 970 * 971 * <p> 972 * This is a shortcut for calling <code>header(<js>"Origin"</js>, value);</code> 973 * 974 * @param value The new header value. 975 * @return This object (for method chaining). 976 */ 977 public RestClientBuilder origin(Object value) { 978 return header("If-Unmodified-Since", value); 979 } 980 981 /** 982 * Sets the value for the <c>Pragma</c> request header. 983 * 984 * <p> 985 * This is a shortcut for calling <code>header(<js>"Pragma"</js>, value);</code> 986 * 987 * @param value The new header value. 988 * @return This object (for method chaining). 989 */ 990 public RestClientBuilder pragma(Object value) { 991 return header("Pragma", value); 992 } 993 994 /** 995 * Sets the value for the <c>Proxy-Authorization</c> request header. 996 * 997 * <p> 998 * This is a shortcut for calling <code>header(<js>"Proxy-Authorization"</js>, value);</code> 999 * 1000 * @param value The new header value. 1001 * @return This object (for method chaining). 1002 */ 1003 public RestClientBuilder proxyAuthorization(Object value) { 1004 return header("Proxy-Authorization", value); 1005 } 1006 1007 /** 1008 * Sets the value for the <c>Range</c> request header. 1009 * 1010 * <p> 1011 * This is a shortcut for calling <code>header(<js>"Range"</js>, value);</code> 1012 * 1013 * @param value The new header value. 1014 * @return This object (for method chaining). 1015 */ 1016 public RestClientBuilder range(Object value) { 1017 return header("Range", value); 1018 } 1019 1020 /** 1021 * Sets the value for the <c>Referer</c> request header. 1022 * 1023 * <p> 1024 * This is a shortcut for calling <code>header(<js>"Referer"</js>, value);</code> 1025 * 1026 * @param value The new header value. 1027 * @return This object (for method chaining). 1028 */ 1029 public RestClientBuilder referer(Object value) { 1030 return header("Referer", value); 1031 } 1032 1033 /** 1034 * Sets the value for the <c>TE</c> request header. 1035 * 1036 * <p> 1037 * This is a shortcut for calling <code>header(<js>"TE"</js>, value);</code> 1038 * 1039 * @param value The new header value. 1040 * @return This object (for method chaining). 1041 */ 1042 public RestClientBuilder te(Object value) { 1043 return header("TE", value); 1044 } 1045 1046 /** 1047 * Sets the value for the <c>User-Agent</c> request header. 1048 * 1049 * <p> 1050 * This is a shortcut for calling <code>header(<js>"User-Agent"</js>, value);</code> 1051 * 1052 * @param value The new header value. 1053 * @return This object (for method chaining). 1054 */ 1055 public RestClientBuilder userAgent(Object value) { 1056 return header("User-Agent", value); 1057 } 1058 1059 /** 1060 * Sets the value for the <c>Upgrade</c> request header. 1061 * 1062 * <p> 1063 * This is a shortcut for calling <code>header(<js>"Upgrade"</js>, value);</code> 1064 * 1065 * @param value The new header value. 1066 * @return This object (for method chaining). 1067 */ 1068 public RestClientBuilder upgrade(Object value) { 1069 return header("Upgrade", value); 1070 } 1071 1072 /** 1073 * Sets the value for the <c>Via</c> request header. 1074 * 1075 * <p> 1076 * This is a shortcut for calling <code>header(<js>"Via"</js>, value);</code> 1077 * 1078 * @param value The new header value. 1079 * @return This object (for method chaining). 1080 */ 1081 public RestClientBuilder via(Object value) { 1082 return header("Via", value); 1083 } 1084 1085 /** 1086 * Sets the value for the <c>Warning</c> request header. 1087 * 1088 * <p> 1089 * This is a shortcut for calling <code>header(<js>"Warning"</js>, value);</code> 1090 * 1091 * @param value The new header value. 1092 * @return This object (for method chaining). 1093 */ 1094 public RestClientBuilder warning(Object value) { 1095 return header("Warning", value); 1096 } 1097 1098 //----------------------------------------------------------------------------------------------------------------- 1099 // Properties 1100 //----------------------------------------------------------------------------------------------------------------- 1101 1102 /** 1103 * Configuration property: Executor service. 1104 * 1105 * <p> 1106 * Defines the executor service to use when calling future methods on the {@link RestCall} class. 1107 * 1108 * <p> 1109 * This executor service is used to create {@link Future} objects on the following methods: 1110 * <ul> 1111 * <li>{@link RestCall#runFuture()} 1112 * <li>{@link RestCall#getResponseFuture(Class)} 1113 * <li>{@link RestCall#getResponseFuture(Type,Type...)} 1114 * <li>{@link RestCall#getResponseAsString()} 1115 * </ul> 1116 * 1117 * <p> 1118 * The default executor service is a single-threaded {@link ThreadPoolExecutor} with a 30 second timeout 1119 * and a queue size of 10. 1120 * 1121 * <ul class='seealso'> 1122 * <li class='jf'>{@link RestClient#RESTCLIENT_executorService} 1123 * <li class='jf'>{@link RestClient#RESTCLIENT_executorServiceShutdownOnClose} 1124 * </ul> 1125 * 1126 * @param executorService The executor service. 1127 * @param shutdownOnClose Call {@link ExecutorService#shutdown()} when {@link RestClient#close()} is called. 1128 * @return This object (for method chaining). 1129 */ 1130 public RestClientBuilder executorService(ExecutorService executorService, boolean shutdownOnClose) { 1131 set(RESTCLIENT_executorService, executorService); 1132 set(RESTCLIENT_executorServiceShutdownOnClose, shutdownOnClose); 1133 return this; 1134 } 1135 1136 /** 1137 * Configuration property: Request headers. 1138 * 1139 * <ul class='seealso'> 1140 * <li class='jf'>{@link RestClient#RESTCLIENT_headers} 1141 * </ul> 1142 * 1143 * @param key The header name. 1144 * @param value The header value. 1145 * @return This object (for method chaining). 1146 */ 1147 public RestClientBuilder header(String key, Object value) { 1148 return addTo(RESTCLIENT_headers, key, value); 1149 } 1150 1151 /** 1152 * Configuration property: Keep HttpClient open. 1153 * 1154 * <p> 1155 * Don't close this client when the {@link RestClient#close()} method is called. 1156 * 1157 * <ul class='seealso'> 1158 * <li class='jf'>{@link RestClient#RESTCLIENT_keepHttpClientOpen} 1159 * </ul> 1160 * 1161 * @param value 1162 * The new value for this property. 1163 * <br>The default value is <jk>false</jk>. 1164 * @return This object (for method chaining). 1165 */ 1166 public RestClientBuilder keepHttpClientOpen(boolean value) { 1167 return set(RESTCLIENT_keepHttpClientOpen, value); 1168 } 1169 1170 /** 1171 * Configuration property: Keep HttpClient open. 1172 * 1173 * <p> 1174 * Don't close this client when the {@link RestClient#close()} method is called. 1175 * 1176 * <ul class='seealso'> 1177 * <li class='jf'>{@link RestClient#RESTCLIENT_keepHttpClientOpen} 1178 * </ul> 1179 * 1180 * @return This object (for method chaining). 1181 */ 1182 public RestClientBuilder keepHttpClientOpen() { 1183 return keepHttpClientOpen(true); 1184 } 1185 1186 /** 1187 * Configuration property: Call interceptors. 1188 * 1189 * <p> 1190 * Adds an interceptor that gets called immediately after a connection is made. 1191 * 1192 * <ul class='seealso'> 1193 * <li class='jf'>{@link RestClient#RESTCLIENT_interceptors} 1194 * </ul> 1195 * 1196 * @param value The values to add to this setting. 1197 * @return This object (for method chaining). 1198 */ 1199 public RestClientBuilder interceptors(RestCallInterceptor...value) { 1200 return addTo(RESTCLIENT_interceptors, value); 1201 } 1202 1203 /** 1204 * Configuration property: Marshall 1205 * 1206 * <p> 1207 * Shortcut for specifying the {@link RestClient#RESTCLIENT_serializer} and {@link RestClient#RESTCLIENT_parser} 1208 * using the serializer and parser defined in a marshall. 1209 * 1210 * @param value The values to add to this setting. 1211 * @return This object (for method chaining). 1212 */ 1213 public RestClientBuilder marshall(Marshall value) { 1214 if (value == null) 1215 serializer((Serializer)null).parser((Parser)null); 1216 else 1217 serializer(value.getSerializer()).parser(value.getParser()); 1218 return this; 1219 } 1220 1221 /** 1222 * Configuration property: Parser. 1223 * 1224 * <p> 1225 * The parser to use for parsing POJOs in response bodies. 1226 * 1227 * <ul class='seealso'> 1228 * <li class='jf'>{@link RestClient#RESTCLIENT_parser} 1229 * </ul> 1230 * 1231 * @param value 1232 * The new value for this setting. 1233 * <br>The default value is {@link JsonParser#DEFAULT}. 1234 * @return This object (for method chaining). 1235 */ 1236 public RestClientBuilder parser(Class<? extends Parser> value) { 1237 return set(RESTCLIENT_parser, value); 1238 } 1239 1240 /** 1241 * Configuration property: Parser. 1242 * 1243 * <p> 1244 * Same as {@link #parser(Parser)} except takes in a parser instance. 1245 * 1246 * <ul class='seealso'> 1247 * <li class='jf'>{@link RestClient#RESTCLIENT_parser} 1248 * </ul> 1249 * 1250 * @param value 1251 * The new value for this setting. 1252 * <br>The default value is {@link JsonParser#DEFAULT}. 1253 * @return This object (for method chaining). 1254 */ 1255 public RestClientBuilder parser(Parser value) { 1256 return set(RESTCLIENT_parser, value); 1257 } 1258 1259 /** 1260 * Configuration property: Part parser. 1261 * 1262 * <p> 1263 * The parser to use for parsing POJOs from form data, query parameters, headers, and path variables. 1264 * 1265 * <ul class='seealso'> 1266 * <li class='jf'>{@link RestClient#RESTCLIENT_partParser} 1267 * </ul> 1268 * 1269 * @param value 1270 * The new value for this setting. 1271 * <br>The default value is {@link OpenApiParser}. 1272 * @return This object (for method chaining). 1273 */ 1274 public RestClientBuilder partParser(Class<? extends HttpPartParser> value) { 1275 return set(RESTCLIENT_partParser, value); 1276 } 1277 1278 /** 1279 * Configuration property: Part parser. 1280 * 1281 * <p> 1282 * Same as {@link #partParser(Class)} but takes in a parser instance. 1283 * 1284 * <ul class='seealso'> 1285 * <li class='jf'>{@link RestClient#RESTCLIENT_partParser} 1286 * </ul> 1287 * 1288 * @param value 1289 * The new value for this setting. 1290 * <br>The default value is {@link OpenApiParser}. 1291 * @return This object (for method chaining). 1292 */ 1293 public RestClientBuilder partParser(HttpPartParser value) { 1294 return set(RESTCLIENT_partParser, value); 1295 } 1296 1297 /** 1298 * Configuration property: Part serializer. 1299 * 1300 * <p> 1301 * The serializer to use for serializing POJOs in form data, query parameters, headers, and path variables. 1302 * 1303 * <ul class='seealso'> 1304 * <li class='jf'>{@link RestClient#RESTCLIENT_partSerializer} 1305 * </ul> 1306 * 1307 * @param value 1308 * The new value for this setting. 1309 * <br>The default value is {@link OpenApiSerializer}. 1310 * @return This object (for method chaining). 1311 */ 1312 public RestClientBuilder partSerializer(Class<? extends HttpPartSerializer> value) { 1313 return set(RESTCLIENT_partSerializer, value); 1314 } 1315 1316 /** 1317 * Configuration property: Part serializer. 1318 * 1319 * <p> 1320 * Same as {@link #partSerializer(Class)} but takes in a parser instance. 1321 * 1322 * <ul class='seealso'> 1323 * <li class='jf'>{@link RestClient#RESTCLIENT_partSerializer} 1324 * </ul> 1325 * 1326 * @param value 1327 * The new value for this setting. 1328 * <br>The default value is {@link OpenApiSerializer}. 1329 * @return This object (for method chaining). 1330 */ 1331 public RestClientBuilder partSerializer(HttpPartSerializer value) { 1332 return set(RESTCLIENT_partSerializer, value); 1333 } 1334 1335 /** 1336 * Make HTTP calls retryable if an error response (>=400) is received. 1337 * 1338 * <ul class='seealso'> 1339 * <li class='jf'>{@link RestClient#RESTCLIENT_retries} 1340 * <li class='jf'>{@link RestClient#RESTCLIENT_retryInterval} 1341 * <li class='jf'>{@link RestClient#RESTCLIENT_retryOn} 1342 * </ul> 1343 * 1344 * @param retries The number of retries to attempt. 1345 * @param interval The time in milliseconds between attempts. 1346 * @param retryOn 1347 * Optional object used for determining whether a retry should be attempted. 1348 * If <jk>null</jk>, uses {@link RetryOn#DEFAULT}. 1349 * @return This object (for method chaining). 1350 */ 1351 public RestClientBuilder retryable(int retries, int interval, RetryOn retryOn) { 1352 set(RESTCLIENT_retries, retries); 1353 set(RESTCLIENT_retryInterval, interval); 1354 set(RESTCLIENT_retryOn, retryOn); 1355 return this; 1356 } 1357 1358 /** 1359 * Configuration property: Root URI. 1360 * 1361 * <p> 1362 * When set, relative URL strings passed in through the various rest call methods (e.g. {@link RestClient#doGet(Object)} 1363 * will be prefixed with the specified root. 1364 * <br>This root URL is ignored on those methods if you pass in a {@link URL}, {@link URI}, or an absolute URL string. 1365 * 1366 * <ul class='seealso'> 1367 * <li class='jf'>{@link RestClient#RESTCLIENT_rootUri} 1368 * </ul> 1369 * 1370 * @param value 1371 * The root URL to prefix to relative URL strings. 1372 * <br>Trailing slashes are trimmed. 1373 * <br>Usually a <c>String</c> but you can also pass in <c>URI</c> and <c>URL</c> objects as well. 1374 * @return This object (for method chaining). 1375 */ 1376 public RestClientBuilder rootUrl(Object value) { 1377 return set(RESTCLIENT_rootUri, value); 1378 } 1379 1380 /** 1381 * Configuration property: Request query parameters. 1382 * 1383 * <ul class='seealso'> 1384 * <li class='jf'>{@link RestClient#RESTCLIENT_query} 1385 * </ul> 1386 * 1387 * @param key The query parameter name. 1388 * @param value The query parameter value value. 1389 * @return This object (for method chaining). 1390 */ 1391 public RestClientBuilder query(String key, Object value) { 1392 return addTo(RESTCLIENT_query, key, value); 1393 } 1394 1395 /** 1396 * Configuration property: Serializer. 1397 * 1398 * <p> 1399 * The serializer to use for serializing POJOs in request bodies. 1400 * 1401 * <ul class='seealso'> 1402 * <li class='jf'>{@link RestClient#RESTCLIENT_serializer} 1403 * </ul> 1404 * 1405 * @param value 1406 * The new value for this setting. 1407 * <br>The default is {@link JsonSerializer}. 1408 * @return This object (for method chaining). 1409 */ 1410 public RestClientBuilder serializer(Class<? extends Serializer> value) { 1411 return set(RESTCLIENT_serializer, value); 1412 } 1413 1414 /** 1415 * Configuration property: Serializer. 1416 * 1417 * <p> 1418 * Same as {@link #serializer(Class)} but takes in a serializer instance. 1419 * 1420 * <ul class='seealso'> 1421 * <li class='jf'>{@link RestClient#RESTCLIENT_serializer} 1422 * </ul> 1423 * 1424 * @param value 1425 * The new value for this setting. 1426 * <br>The default is {@link JsonSerializer}. 1427 * @return This object (for method chaining). 1428 */ 1429 public RestClientBuilder serializer(Serializer value) { 1430 return set(RESTCLIENT_serializer, value); 1431 } 1432 1433 /** 1434 * Configuration property: Add <js>"_type"</js> properties when needed. 1435 * 1436 * <p> 1437 * If <jk>true</jk>, then <js>"_type"</js> properties will be added to beans if their type cannot be inferred 1438 * through reflection. 1439 * 1440 * <ul class='seealso'> 1441 * <li class='jf'>{@link Serializer#SERIALIZER_addBeanTypes} 1442 * </ul> 1443 * 1444 * @param value 1445 * The new value for this property. 1446 * <br>The default is <jk>false</jk>. 1447 * @return This object (for method chaining). 1448 */ 1449 public RestClientBuilder addBeanTypes(boolean value) { 1450 return set(SERIALIZER_addBeanTypes, value); 1451 } 1452 1453 /** 1454 * Configuration property: Add <js>"_type"</js> properties when needed. 1455 * 1456 * <p> 1457 * Shortcut for calling <code>addBeanTypes(<jk>true</jk>)</code>. 1458 * 1459 * <ul class='seealso'> 1460 * <li class='jf'>{@link Serializer#SERIALIZER_addBeanTypes} 1461 * </ul> 1462 * 1463 * @return This object (for method chaining). 1464 */ 1465 public RestClientBuilder addBeanTypes() { 1466 return set(SERIALIZER_addBeanTypes, true); 1467 } 1468 1469 /** 1470 * Configuration property: Add type attribute to root nodes. 1471 * 1472 * <p> 1473 * When disabled, it is assumed that the parser knows the exact Java POJO type being parsed, and therefore top-level 1474 * type information that might normally be included to determine the data type will not be serialized. 1475 * 1476 * <ul class='seealso'> 1477 * <li class='jf'>{@link Serializer#SERIALIZER_addRootType} 1478 * </ul> 1479 * 1480 * @param value 1481 * The new value for this property. 1482 * <br>The default is <jk>false</jk>. 1483 * @return This object (for method chaining). 1484 */ 1485 public RestClientBuilder addRootType(boolean value) { 1486 return set(SERIALIZER_addRootType, value); 1487 } 1488 1489 /** 1490 * Configuration property: Add type attribute to root nodes. 1491 * 1492 * <p> 1493 * Shortcut for calling <code>addRootType(<jk>true</jk>)</code>. 1494 * 1495 * <ul class='seealso'> 1496 * <li class='jf'>{@link Serializer#SERIALIZER_addRootType} 1497 * </ul> 1498 * 1499 * @return This object (for method chaining). 1500 */ 1501 public RestClientBuilder addRootType() { 1502 return set(SERIALIZER_addRootType, true); 1503 } 1504 1505 /** 1506 * Configuration property: Automatically detect POJO recursions. 1507 * 1508 * <p> 1509 * Specifies that recursions should be checked for during serialization. 1510 * 1511 * <ul class='notes'> 1512 * <li> 1513 * Checking for recursion can cause a small performance penalty. 1514 * </ul> 1515 * 1516 * <ul class='seealso'> 1517 * <li class='jf'>{@link BeanTraverseContext#BEANTRAVERSE_detectRecursions} 1518 * </ul> 1519 * 1520 * @param value 1521 * The new value for this property. 1522 * <br>The default is <jk>false</jk>. 1523 * @return This object (for method chaining). 1524 */ 1525 public RestClientBuilder detectRecursions(boolean value) { 1526 return set(BEANTRAVERSE_detectRecursions, value); 1527 } 1528 1529 /** 1530 * Configuration property: Automatically detect POJO recursions. 1531 * 1532 * <p> 1533 * Shortcut for calling <code>detectRecursions(<jk>true</jk>)</code>. 1534 * 1535 * <ul class='seealso'> 1536 * <li class='jf'>{@link BeanTraverseContext#BEANTRAVERSE_detectRecursions} 1537 * </ul> 1538 * 1539 * @return This object (for method chaining). 1540 */ 1541 public RestClientBuilder detectRecursions() { 1542 return set(BEANTRAVERSE_detectRecursions, true); 1543 } 1544 1545 /** 1546 * Configuration property: Ignore recursion errors. 1547 * 1548 * <p> 1549 * If <jk>true</jk>, when we encounter the same object when serializing a tree, we set the value to <jk>null</jk>. 1550 * Otherwise, an exception is thrown. 1551 * 1552 * <ul class='notes'> 1553 * <li> 1554 * Checking for recursion can cause a small performance penalty. 1555 * </ul> 1556 * 1557 * <ul class='seealso'> 1558 * <li class='jf'>{@link BeanTraverseContext#BEANTRAVERSE_ignoreRecursions} 1559 * </ul> 1560 * 1561 * @param value 1562 * The new value for this property. 1563 * <br>The default is <jk>false</jk>. 1564 * @return This object (for method chaining). 1565 */ 1566 public RestClientBuilder ignoreRecursions(boolean value) { 1567 return set(BEANTRAVERSE_ignoreRecursions, value); 1568 } 1569 1570 /** 1571 * Configuration property: Ignore recursion errors. 1572 * 1573 * <p> 1574 * Shortcut for calling <code>ignoreRecursions(<jk>true</jk>)</code>. 1575 * 1576 * <ul class='seealso'> 1577 * <li class='jf'>{@link BeanTraverseContext#BEANTRAVERSE_ignoreRecursions} 1578 * </ul> 1579 * 1580 * @return This object (for method chaining). 1581 */ 1582 public RestClientBuilder ignoreRecursions() { 1583 return set(BEANTRAVERSE_ignoreRecursions, true); 1584 } 1585 1586 /** 1587 * Configuration property: Initial depth. 1588 * 1589 * <p> 1590 * The initial indentation level at the root. 1591 * 1592 * <ul class='seealso'> 1593 * <li class='jf'>{@link BeanTraverseContext#BEANTRAVERSE_initialDepth} 1594 * </ul> 1595 * 1596 * @param value 1597 * The new value for this property. 1598 * <br>The default is <c>0</c>. 1599 * @return This object (for method chaining). 1600 */ 1601 public RestClientBuilder initialDepth(int value) { 1602 return set(BEANTRAVERSE_initialDepth, value); 1603 } 1604 1605 /** 1606 * Configuration property: Serializer listener. 1607 * 1608 * <p> 1609 * Class used to listen for errors and warnings that occur during serialization. 1610 * 1611 * <ul class='seealso'> 1612 * <li class='jf'>{@link Serializer#SERIALIZER_listener} 1613 * </ul> 1614 * 1615 * @param value 1616 * The new value for this property. 1617 * @return This object (for method chaining). 1618 */ 1619 public RestClientBuilder listenerS(Class<? extends SerializerListener> value) { 1620 return set(SERIALIZER_listener, value); 1621 } 1622 1623 /** 1624 * Configuration property: Max serialization depth. 1625 * 1626 * <p> 1627 * Abort serialization if specified depth is reached in the POJO tree. 1628 * <br>If this depth is exceeded, an exception is thrown. 1629 * <br>This prevents stack overflows from occurring when trying to serialize models with recursive references. 1630 * 1631 * <ul class='seealso'> 1632 * <li class='jf'>{@link BeanTraverseContext#BEANTRAVERSE_maxDepth} 1633 * </ul> 1634 * 1635 * @param value 1636 * The new value for this property. 1637 * <br>The default is <c>100</c>. 1638 * @return This object (for method chaining). 1639 */ 1640 public RestClientBuilder maxDepth(int value) { 1641 return set(BEANTRAVERSE_maxDepth, value); 1642 } 1643 1644 /** 1645 * Configuration property: Sort arrays and collections alphabetically. 1646 * 1647 * <p> 1648 * Copies and sorts the contents of arrays and collections before serializing them. 1649 * 1650 * <ul class='seealso'> 1651 * <li class='jf'>{@link Serializer#SERIALIZER_sortCollections} 1652 * </ul> 1653 * 1654 * @param value 1655 * The new value for this property. 1656 * <br>The default is <jk>false</jk>. 1657 * @return This object (for method chaining). 1658 */ 1659 public RestClientBuilder sortCollections(boolean value) { 1660 return set(SERIALIZER_sortCollections, value); 1661 } 1662 1663 /** 1664 * Configuration property: Sort arrays and collections alphabetically. 1665 * 1666 * <p> 1667 * Shortcut for calling <code>sortCollections(<jk>true</jk>)</code>. 1668 * 1669 * <ul class='seealso'> 1670 * <li class='jf'>{@link Serializer#SERIALIZER_sortCollections} 1671 * </ul> 1672 * 1673 * @return This object (for method chaining). 1674 */ 1675 public RestClientBuilder sortCollections() { 1676 return set(SERIALIZER_sortCollections, true); 1677 } 1678 1679 /** 1680 * Sets the {@link Serializer#SERIALIZER_sortMaps} property on all serializers in this group. 1681 * 1682 * <p> 1683 * Copies and sorts the contents of maps before serializing them. 1684 * 1685 * <ul class='seealso'> 1686 * <li class='jf'>{@link Serializer#SERIALIZER_sortMaps} 1687 * </ul> 1688 * 1689 * @param value The new value for this property. 1690 * @return This object (for method chaining). 1691 */ 1692 public RestClientBuilder sortMaps(boolean value) { 1693 return set(SERIALIZER_sortMaps, value); 1694 } 1695 1696 /** 1697 * Configuration property: Sort maps alphabetically. 1698 * 1699 * <p> 1700 * Shortcut for calling <code>sortMaps(<jk>true</jk>)</code>. 1701 * 1702 * <ul class='seealso'> 1703 * <li class='jf'>{@link Serializer#SERIALIZER_sortMaps} 1704 * </ul> 1705 * 1706 * @return This object (for method chaining). 1707 */ 1708 public RestClientBuilder sortMaps() { 1709 return set(SERIALIZER_sortMaps, true); 1710 } 1711 1712 /** 1713 * Configuration property: Trim empty lists and arrays. 1714 * 1715 * <p> 1716 * If <jk>true</jk>, empty list values will not be serialized to the output. 1717 * 1718 * <ul class='seealso'> 1719 * <li class='jf'>{@link Serializer#SERIALIZER_trimEmptyCollections} 1720 * </ul> 1721 * 1722 * @param value 1723 * The new value for this property. 1724 * <br>The default is <jk>false</jk>. 1725 * @return This object (for method chaining). 1726 */ 1727 public RestClientBuilder trimEmptyCollections(boolean value) { 1728 return set(SERIALIZER_trimEmptyCollections, value); 1729 } 1730 1731 /** 1732 * Configuration property: Trim empty lists and arrays. 1733 * 1734 * <p> 1735 * Shortcut for calling <code>trimEmptyCollections(<jk>true</jk>)</code>. 1736 * 1737 * <ul class='seealso'> 1738 * <li class='jf'>{@link Serializer#SERIALIZER_trimEmptyCollections} 1739 * </ul> 1740 * 1741 * @return This object (for method chaining). 1742 */ 1743 public RestClientBuilder trimEmptyCollections() { 1744 return set(SERIALIZER_trimEmptyCollections, true); 1745 } 1746 1747 /** 1748 * Configuration property: Trim empty maps. 1749 * 1750 * <p> 1751 * If <jk>true</jk>, empty map values will not be serialized to the output. 1752 * 1753 * <ul class='seealso'> 1754 * <li class='jf'>{@link Serializer#SERIALIZER_trimEmptyMaps} 1755 * </ul> 1756 * 1757 * @param value 1758 * The new value for this property. 1759 * <br>The default is <jk>false</jk>. 1760 * @return This object (for method chaining). 1761 */ 1762 public RestClientBuilder trimEmptyMaps(boolean value) { 1763 return set(SERIALIZER_trimEmptyMaps, value); 1764 } 1765 1766 /** 1767 * Configuration property: Trim empty maps. 1768 * 1769 * <p> 1770 * Shortcut for calling <code>trimEmptyMaps(<jk>true</jk>)</code>. 1771 * 1772 * <ul class='seealso'> 1773 * <li class='jf'>{@link Serializer#SERIALIZER_trimEmptyMaps} 1774 * </ul> 1775 * 1776 * @return This object (for method chaining). 1777 */ 1778 public RestClientBuilder trimEmptyMaps() { 1779 return set(SERIALIZER_trimEmptyMaps, true); 1780 } 1781 1782 /** 1783 * Configuration property: Trim null bean property values. 1784 * 1785 * <p> 1786 * If <jk>true</jk>, null bean values will not be serialized to the output. 1787 * 1788 * <ul class='seealso'> 1789 * <li class='jf'>{@link Serializer#SERIALIZER_trimNullProperties} 1790 * </ul> 1791 * 1792 * @param value 1793 * The new value for this property. 1794 * <br>The default is <jk>true</jk>. 1795 * @return This object (for method chaining). 1796 */ 1797 public RestClientBuilder trimNullProperties(boolean value) { 1798 return set(SERIALIZER_trimNullProperties, value); 1799 } 1800 1801 /** 1802 * Configuration property: Trim strings. 1803 * 1804 * <p> 1805 * If <jk>true</jk>, string values will be trimmed of whitespace using {@link String#trim()} before being serialized. 1806 * 1807 * <ul class='seealso'> 1808 * <li class='jf'>{@link Serializer#SERIALIZER_trimStrings} 1809 * </ul> 1810 * 1811 * @param value 1812 * The new value for this property. 1813 * <br>The default is <jk>false</jk>. 1814 * @return This object (for method chaining). 1815 */ 1816 public RestClientBuilder trimStringsS(boolean value) { 1817 return set(SERIALIZER_trimStrings, value); 1818 } 1819 1820 /** 1821 * Configuration property: Trim strings. 1822 * 1823 * <p> 1824 * Shortcut for calling <code>trimStrings(<jk>true</jk>)</code>. 1825 * 1826 * <ul class='seealso'> 1827 * <li class='jf'>{@link Serializer#SERIALIZER_trimStrings} 1828 * </ul> 1829 * 1830 * @return This object (for method chaining). 1831 */ 1832 public RestClientBuilder trimStringsS() { 1833 return set(SERIALIZER_trimStrings, true); 1834 } 1835 1836 /** 1837 * Configuration property: URI context bean. 1838 * 1839 * <p> 1840 * Bean used for resolution of URIs to absolute or root-relative form. 1841 * 1842 * <ul class='seealso'> 1843 * <li class='jf'>{@link Serializer#SERIALIZER_uriContext} 1844 * </ul> 1845 * 1846 * @param value The new value for this property. 1847 * @return This object (for method chaining). 1848 */ 1849 public RestClientBuilder uriContext(UriContext value) { 1850 return set(SERIALIZER_uriContext, value); 1851 } 1852 1853 /** 1854 * Configuration property: URI relativity. 1855 * 1856 * <p> 1857 * Defines what relative URIs are relative to when serializing URI/URL objects. 1858 * 1859 * <ul class='seealso'> 1860 * <li class='jf'>{@link Serializer#SERIALIZER_uriRelativity} 1861 * </ul> 1862 * 1863 * @param value 1864 * The new value for this property. 1865 * <br>The default is {@link UriRelativity#RESOURCE} 1866 * @return This object (for method chaining). 1867 */ 1868 public RestClientBuilder uriRelativity(UriRelativity value) { 1869 return set(SERIALIZER_uriRelativity, value); 1870 } 1871 1872 /** 1873 * Configuration property: URI resolution. 1874 * 1875 * <p> 1876 * Defines the resolution level for URIs when serializing URI/URL objects. 1877 * 1878 * <ul class='seealso'> 1879 * <li class='jf'>{@link Serializer#SERIALIZER_uriResolution} 1880 * </ul> 1881 * 1882 * @param value 1883 * The new value for this property. 1884 * <br>The default is {@link UriResolution#NONE} 1885 * @return This object (for method chaining). 1886 */ 1887 public RestClientBuilder uriResolution(UriResolution value) { 1888 return set(SERIALIZER_uriResolution, value); 1889 } 1890 1891 /** 1892 * Configuration property: Maximum indentation. 1893 * 1894 * <p> 1895 * Specifies the maximum indentation level in the serialized document. 1896 * 1897 * <ul class='seealso'> 1898 * <li class='jf'>{@link WriterSerializer#WSERIALIZER_maxIndent} 1899 * </ul> 1900 * 1901 * @param value 1902 * The new value for this property. 1903 * <br>The default is <c>100</c>. 1904 * @return This object (for method chaining). 1905 */ 1906 public RestClientBuilder maxIndent(int value) { 1907 return set(WSERIALIZER_maxIndent, value); 1908 } 1909 1910 /** 1911 * Configuration property: Quote character. 1912 * 1913 * <p> 1914 * This is the character used for quoting attributes and values. 1915 * 1916 * <ul class='seealso'> 1917 * <li class='jf'>{@link WriterSerializer#WSERIALIZER_quoteChar} 1918 * </ul> 1919 * 1920 * @param value 1921 * The new value for this property. 1922 * <br>The default is <js>'"'</js>. 1923 * @return This object (for method chaining). 1924 */ 1925 public RestClientBuilder quoteChar(char value) { 1926 return set(WSERIALIZER_quoteChar, value); 1927 } 1928 1929 /** 1930 * Configuration property: Quote character. 1931 * 1932 * <p> 1933 * Shortcut for calling <code>quoteChar(<js>'\''</js>)</code>. 1934 * 1935 * <ul class='seealso'> 1936 * <li class='jf'>{@link WriterSerializer#WSERIALIZER_quoteChar} 1937 * </ul> 1938 * 1939 * @return This object (for method chaining). 1940 */ 1941 public RestClientBuilder sq() { 1942 return set(WSERIALIZER_quoteChar, '\''); 1943 } 1944 1945 /** 1946 * Configuration property: Use whitespace. 1947 * 1948 * <p> 1949 * If <jk>true</jk>, newlines and indentation and spaces are added to the output to improve readability. 1950 * 1951 * <ul class='seealso'> 1952 * <li class='jf'>{@link WriterSerializer#WSERIALIZER_useWhitespace} 1953 * </ul> 1954 * 1955 * @param value 1956 * The new value for this property. 1957 * <br>The default is <jk>false</jk>. 1958 * @return This object (for method chaining). 1959 */ 1960 public RestClientBuilder useWhitespace(boolean value) { 1961 return set(WSERIALIZER_useWhitespace, value); 1962 } 1963 1964 /** 1965 * Configuration property: Use whitespace. 1966 * 1967 * <p> 1968 * Shortcut for calling <code>useWhitespace(<jk>true</jk>)</code>. 1969 * 1970 * <ul class='seealso'> 1971 * <li class='jf'>{@link WriterSerializer#WSERIALIZER_useWhitespace} 1972 * </ul> 1973 * @return This object (for method chaining). 1974 */ 1975 public RestClientBuilder useWhitespace() { 1976 return set(WSERIALIZER_useWhitespace, true); 1977 } 1978 1979 /** 1980 * Configuration property: Use whitespace. 1981 * 1982 * <p> 1983 * Shortcut for calling <code>useWhitespace(<jk>true</jk>)</code>. 1984 * 1985 * <ul class='seealso'> 1986 * <li class='jf'>{@link WriterSerializer#WSERIALIZER_useWhitespace} 1987 * </ul> 1988 * 1989 * @return This object (for method chaining). 1990 */ 1991 public RestClientBuilder ws() { 1992 return set(WSERIALIZER_useWhitespace, true); 1993 } 1994 1995 /** 1996 * Configuration property: Binary string format. 1997 * 1998 * <p> 1999 * When using the {@link Serializer#serializeToString(Object)} method on stream-based serializers, this defines the format to use 2000 * when converting the resulting byte array to a string. 2001 * 2002 * <ul class='javatree'> 2003 * <li class='jf'>{@link OutputStreamSerializer#OSSERIALIZER_binaryFormat} 2004 * </ul> 2005 * 2006 * @param value 2007 * The new value for this property. 2008 * <br>The default is {@link BinaryFormat#HEX}. 2009 * @return This object (for method chaining). 2010 */ 2011 public RestClientBuilder binaryOutputFormat(BinaryFormat value) { 2012 return set(OSSERIALIZER_binaryFormat, value); 2013 } 2014 2015 /** 2016 * Configuration property: Auto-close streams. 2017 * 2018 * If <jk>true</jk>, <l>InputStreams</l> and <l>Readers</l> passed into parsers will be closed 2019 * after parsing is complete. 2020 * 2021 * <ul class='seealso'> 2022 * <li class='jf'>{@link Parser#PARSER_autoCloseStreams} 2023 * </ul> 2024 * 2025 * @param value 2026 * The new value for this property. 2027 * <br>The default value is <jk>false</jk>. 2028 * @return This object (for method chaining). 2029 */ 2030 public RestClientBuilder autoCloseStreams(boolean value) { 2031 return set(PARSER_autoCloseStreams, value); 2032 } 2033 2034 /** 2035 * Configuration property: Auto-close streams. 2036 * 2037 * <p> 2038 * Shortcut for calling <code>autoCloseStreams(<jk>true</jk>)</code>. 2039 * 2040 * <ul class='seealso'> 2041 * <li class='jf'>{@link Parser#PARSER_autoCloseStreams} 2042 * </ul> 2043 * 2044 * @return This object (for method chaining). 2045 */ 2046 public RestClientBuilder autoCloseStreams() { 2047 return set(PARSER_autoCloseStreams, true); 2048 } 2049 2050 /** 2051 * Configuration property: Debug output lines. 2052 * 2053 * When parse errors occur, this specifies the number of lines of input before and after the 2054 * error location to be printed as part of the exception message. 2055 * 2056 * <ul class='seealso'> 2057 * <li class='jf'>{@link Parser#PARSER_debugOutputLines} 2058 * </ul> 2059 * 2060 * @param value 2061 * The new value for this property. 2062 * <br>The default value is <c>5</c>. 2063 * @return This object (for method chaining). 2064 */ 2065 public RestClientBuilder debugOutputLines(int value) { 2066 set(PARSER_debugOutputLines, value); 2067 return this; 2068 } 2069 2070 /** 2071 * Configuration property: Parser listener. 2072 * 2073 * <p> 2074 * Class used to listen for errors and warnings that occur during parsing. 2075 * 2076 * <ul class='seealso'> 2077 * <li class='jf'>{@link Parser#PARSER_listener} 2078 * </ul> 2079 * 2080 * @param value The new value for this property. 2081 * @return This object (for method chaining). 2082 */ 2083 public RestClientBuilder listenerP(Class<? extends ParserListener> value) { 2084 return set(PARSER_listener, value); 2085 } 2086 2087 /** 2088 * Configuration property: Strict mode. 2089 * 2090 * <p> 2091 * If <jk>true</jk>, strict mode for the parser is enabled. 2092 * 2093 * <ul class='seealso'> 2094 * <li class='jf'>{@link Parser#PARSER_strict} 2095 * </ul> 2096 * 2097 * @param value 2098 * The new value for this property. 2099 * <br>The default value is <jk>false</jk>. 2100 * @return This object (for method chaining). 2101 */ 2102 public RestClientBuilder strict(boolean value) { 2103 return set(PARSER_strict, value); 2104 } 2105 2106 /** 2107 * Configuration property: Strict mode. 2108 * 2109 * <p> 2110 * Shortcut for calling <code>strict(<jk>true</jk>)</code>. 2111 * 2112 * <ul class='seealso'> 2113 * <li class='jf'>{@link Parser#PARSER_strict} 2114 * </ul> 2115 * 2116 * @return This object (for method chaining). 2117 */ 2118 public RestClientBuilder strict() { 2119 return set(PARSER_strict, true); 2120 } 2121 2122 /** 2123 * Configuration property: Trim parsed strings. 2124 * 2125 * <p> 2126 * If <jk>true</jk>, string values will be trimmed of whitespace using {@link String#trim()} before being added to 2127 * the POJO. 2128 * 2129 * <ul class='seealso'> 2130 * <li class='jf'>{@link Parser#PARSER_trimStrings} 2131 * </ul> 2132 * 2133 * @param value 2134 * The new value for this property. 2135 * <br>The default value is <jk>false</jk>. 2136 * @return This object (for method chaining). 2137 */ 2138 public RestClientBuilder trimStringsP(boolean value) { 2139 return set(PARSER_trimStrings, value); 2140 } 2141 2142 /** 2143 * Configuration property: Trim parsed strings. 2144 * 2145 * <p> 2146 * Shortcut for calling <code>trimStrings(<jk>true</jk>)</code>. 2147 * 2148 * <ul class='seealso'> 2149 * <li class='jf'>{@link Parser#PARSER_trimStrings} 2150 * </ul> 2151 * 2152 * @return This object (for method chaining). 2153 */ 2154 public RestClientBuilder trimStringsP() { 2155 return set(PARSER_trimStrings, true); 2156 } 2157 2158 /** 2159 * Configuration property: Unbuffered. 2160 * 2161 * If <jk>true</jk>, don't use internal buffering during parsing. 2162 * 2163 * <ul class='seealso'> 2164 * <li class='jf'>{@link Parser#PARSER_unbuffered} 2165 * </ul> 2166 * 2167 * @param value 2168 * The new value for this property. 2169 * <br>The default value is <jk>false</jk>. 2170 * @return This object (for method chaining). 2171 */ 2172 public RestClientBuilder unbuffered(boolean value) { 2173 return set(PARSER_unbuffered, value); 2174 } 2175 2176 /** 2177 * Configuration property: Unbuffered. 2178 * 2179 * <p> 2180 * Shortcut for calling <code>unbuffered(<jk>true</jk>)</code>. 2181 * 2182 * <ul class='seealso'> 2183 * <li class='jf'>{@link Parser#PARSER_unbuffered} 2184 * </ul> 2185 * 2186 * @return This object (for method chaining). 2187 */ 2188 public RestClientBuilder unbuffered() { 2189 return set(PARSER_unbuffered, true); 2190 } 2191 2192 /** 2193 * Configuration property: File charset. 2194 * 2195 * <p> 2196 * The character set to use for reading <c>Files</c> from the file system. 2197 * 2198 * <ul class='seealso'> 2199 * <li class='jf'>{@link ReaderParser#RPARSER_fileCharset} 2200 * </ul> 2201 * 2202 * @param value 2203 * The new value for this property. 2204 * <br>The default value is <js>"DEFAULT"</js> which causes the system default to be used. 2205 * @return This object (for method chaining). 2206 */ 2207 public RestClientBuilder fileCharset(String value) { 2208 return set(RPARSER_fileCharset, value); 2209 } 2210 2211 /** 2212 * Configuration property: Input stream charset. 2213 * 2214 * <p> 2215 * The character set to use for converting <c>InputStreams</c> and byte arrays to readers. 2216 * 2217 * <ul class='seealso'> 2218 * <li class='jf'>{@link ReaderParser#RPARSER_streamCharset} 2219 * </ul> 2220 * 2221 * @param value 2222 * The new value for this property. 2223 * <br>The default value is <js>"UTF-8"</js>. 2224 * @return This object (for method chaining). 2225 */ 2226 public RestClientBuilder inputStreamCharset(String value) { 2227 return set(RPARSER_streamCharset, value); 2228 } 2229 2230 /** 2231 * Configuration property: Binary input format. 2232 * 2233 * <p> 2234 * When using the {@link Parser#parse(Object,Class)} method on stream-based parsers and the input is a string, this defines the format to use 2235 * when converting the string into a byte array. 2236 * 2237 * <ul class='seealso'> 2238 * <li class='jf'>{@link InputStreamParser#ISPARSER_binaryFormat} 2239 * </ul> 2240 * 2241 * @param value 2242 * The new value for this property. 2243 * <br>The default value is {@link BinaryFormat#HEX}. 2244 * @return This object (for method chaining). 2245 */ 2246 public RestClientBuilder binaryInputFormat(BinaryFormat value) { 2247 return set(ISPARSER_binaryFormat, value); 2248 } 2249 2250 /** 2251 * Configuration property: Parameter format. 2252 * 2253 * <ul class='seealso'> 2254 * <li class='jf'>{@link UonSerializer#UON_paramFormat} 2255 * </ul> 2256 * 2257 * @param value The new value for this property. 2258 * @return This object (for method chaining). 2259 */ 2260 public RestClientBuilder paramFormat(String value) { 2261 return set(UON_paramFormat, value); 2262 } 2263 2264 /** 2265 * Configuration property: Parameter format. 2266 * 2267 * <ul class='seealso'> 2268 * <li class='jf'>{@link UonSerializer#UON_paramFormat} 2269 * </ul> 2270 * 2271 * @return This object (for method chaining). 2272 */ 2273 public RestClientBuilder paramFormatPlain() { 2274 return set(UON_paramFormat, "PLAINTEXT"); 2275 } 2276 2277 @Override /* BeanContextBuilder */ 2278 public RestClientBuilder beanClassVisibility(Visibility value) { 2279 super.beanClassVisibility(value); 2280 return this; 2281 } 2282 2283 @Override /* BeanContextBuilder */ 2284 public RestClientBuilder beanConstructorVisibility(Visibility value) { 2285 super.beanConstructorVisibility(value); 2286 return this; 2287 } 2288 2289 @Override /* BeanContextBuilder */ 2290 @Deprecated 2291 public RestClientBuilder beanDictionary(Class<?>...values) { 2292 super.beanDictionary(values); 2293 return this; 2294 } 2295 2296 @Override /* BeanContextBuilder */ 2297 @Deprecated 2298 public RestClientBuilder beanDictionary(Object...values) { 2299 super.beanDictionary(values); 2300 return this; 2301 } 2302 2303 @Override /* BeanContextBuilder */ 2304 @Deprecated 2305 public RestClientBuilder beanDictionaryReplace(Class<?>...values) { 2306 super.beanDictionaryReplace(values); 2307 return this; 2308 } 2309 2310 @Override /* BeanContextBuilder */ 2311 @Deprecated 2312 public RestClientBuilder beanDictionaryReplace(Object...values) { 2313 super.beanDictionaryReplace(values); 2314 return this; 2315 } 2316 2317 @Override /* BeanContextBuilder */ 2318 @Deprecated 2319 public RestClientBuilder beanDictionaryRemove(Class<?>...values) { 2320 super.beanDictionaryRemove(values); 2321 return this; 2322 } 2323 2324 @Override /* BeanContextBuilder */ 2325 @Deprecated 2326 public RestClientBuilder beanDictionaryRemove(Object...values) { 2327 super.beanDictionaryRemove(values); 2328 return this; 2329 } 2330 2331 @Override /* BeanContextBuilder */ 2332 public RestClientBuilder beanFieldVisibility(Visibility value) { 2333 super.beanFieldVisibility(value); 2334 return this; 2335 } 2336 2337 @Override /* BeanContextBuilder */ 2338 public RestClientBuilder beanFilters(Class<?>...values) { 2339 super.beanFilters(values); 2340 return this; 2341 } 2342 2343 @Override /* BeanContextBuilder */ 2344 public RestClientBuilder beanFilters(Object...values) { 2345 super.beanFilters(values); 2346 return this; 2347 } 2348 2349 @Override /* BeanContextBuilder */ 2350 public RestClientBuilder beanFiltersReplace(Class<?>...values) { 2351 super.beanFiltersReplace(values); 2352 return this; 2353 } 2354 2355 @Override /* BeanContextBuilder */ 2356 public RestClientBuilder beanFiltersReplace(Object...values) { 2357 super.beanFiltersReplace(values); 2358 return this; 2359 } 2360 2361 @Override /* BeanContextBuilder */ 2362 public RestClientBuilder beanFiltersRemove(Class<?>...values) { 2363 super.beanFiltersRemove(values); 2364 return this; 2365 } 2366 2367 @Override /* BeanContextBuilder */ 2368 public RestClientBuilder beanFiltersRemove(Object...values) { 2369 super.beanFiltersRemove(values); 2370 return this; 2371 } 2372 2373 @Override /* BeanContextBuilder */ 2374 public RestClientBuilder beanMapPutReturnsOldValue(boolean value) { 2375 super.beanMapPutReturnsOldValue(value); 2376 return this; 2377 } 2378 2379 @Override /* BeanContextBuilder */ 2380 public RestClientBuilder beanMapPutReturnsOldValue() { 2381 super.beanMapPutReturnsOldValue(); 2382 return this; 2383 } 2384 2385 @Override /* BeanContextBuilder */ 2386 public RestClientBuilder beanMethodVisibility(Visibility value) { 2387 super.beanMethodVisibility(value); 2388 return this; 2389 } 2390 2391 @Override /* BeanContextBuilder */ 2392 public RestClientBuilder beansRequireDefaultConstructor(boolean value) { 2393 super.beansRequireDefaultConstructor(value); 2394 return this; 2395 } 2396 2397 @Override /* BeanContextBuilder */ 2398 public RestClientBuilder beansRequireDefaultConstructor() { 2399 super.beansRequireDefaultConstructor(); 2400 return this; 2401 } 2402 2403 @Override /* BeanContextBuilder */ 2404 public RestClientBuilder beansRequireSerializable(boolean value) { 2405 super.beansRequireSerializable(value); 2406 return this; 2407 } 2408 2409 @Override /* BeanContextBuilder */ 2410 public RestClientBuilder beansRequireSerializable() { 2411 super.beansRequireSerializable(); 2412 return this; 2413 } 2414 2415 @Override /* BeanContextBuilder */ 2416 public RestClientBuilder beansRequireSettersForGetters(boolean value) { 2417 super.beansRequireSettersForGetters(value); 2418 return this; 2419 } 2420 2421 @Override /* BeanContextBuilder */ 2422 public RestClientBuilder beansRequireSettersForGetters() { 2423 super.beansRequireSettersForGetters(); 2424 return this; 2425 } 2426 2427 @Override /* BeanContextBuilder */ 2428 public RestClientBuilder beansRequireSomeProperties(boolean value) { 2429 super.beansRequireSomeProperties(value); 2430 return this; 2431 } 2432 2433 @Override /* BeanContextBuilder */ 2434 public RestClientBuilder beanTypePropertyName(String value) { 2435 super.beanTypePropertyName(value); 2436 return this; 2437 } 2438 2439 @Override /* BeanContextBuilder */ 2440 public RestClientBuilder bpi(Class<?> beanClass, String value) { 2441 super.bpi(beanClass, value); 2442 return this; 2443 } 2444 2445 @Override /* BeanContextBuilder */ 2446 public RestClientBuilder bpi(Map<String,String> values) { 2447 super.bpi(values); 2448 return this; 2449 } 2450 2451 @Override /* BeanContextBuilder */ 2452 public RestClientBuilder bpi(String beanClassName, String value) { 2453 super.bpi(beanClassName, value); 2454 return this; 2455 } 2456 2457 @Override /* BeanContextBuilder */ 2458 public RestClientBuilder bpx(Class<?> beanClass, String properties) { 2459 super.bpx(beanClass, properties); 2460 return this; 2461 } 2462 2463 @Override /* BeanContextBuilder */ 2464 public RestClientBuilder bpx(Map<String,String> values) { 2465 super.bpx(values); 2466 return this; 2467 } 2468 2469 @Override /* BeanContextBuilder */ 2470 public RestClientBuilder bpx(String beanClassName, String value) { 2471 super.bpx(beanClassName, value); 2472 return this; 2473 } 2474 2475 @Override /* BeanContextBuilder */ 2476 public RestClientBuilder bpro(Class<?> beanClass, String value) { 2477 super.bpro(beanClass, value); 2478 return this; 2479 } 2480 2481 @Override /* BeanContextBuilder */ 2482 public RestClientBuilder bpro(Map<String,String> values) { 2483 super.bpro(values); 2484 return this; 2485 } 2486 2487 @Override /* BeanContextBuilder */ 2488 public RestClientBuilder bpro(String beanClassName, String value) { 2489 super.bpro(beanClassName, value); 2490 return this; 2491 } 2492 2493 @Override /* BeanContextBuilder */ 2494 public RestClientBuilder bpwo(Class<?> beanClass, String properties) { 2495 super.bpwo(beanClass, properties); 2496 return this; 2497 } 2498 2499 @Override /* BeanContextBuilder */ 2500 public RestClientBuilder bpwo(Map<String,String> values) { 2501 super.bpwo(values); 2502 return this; 2503 } 2504 2505 @Override /* BeanContextBuilder */ 2506 public RestClientBuilder bpwo(String beanClassName, String value) { 2507 super.bpwo(beanClassName, value); 2508 return this; 2509 } 2510 2511 @Override /* BeanContextBuilder */ 2512 public RestClientBuilder debug() { 2513 super.debug(); 2514 return this; 2515 } 2516 2517 @Override /* BeanContextBuilder */ 2518 public RestClientBuilder debug(boolean value) { 2519 super.debug(value); 2520 return this; 2521 } 2522 2523 @Override /* BeanContextBuilder */ 2524 public RestClientBuilder dictionary(Class<?>...values) { 2525 super.dictionary(values); 2526 return this; 2527 } 2528 2529 @Override /* BeanContextBuilder */ 2530 public RestClientBuilder dictionary(Object...values) { 2531 super.dictionary(values); 2532 return this; 2533 } 2534 2535 @Override /* BeanContextBuilder */ 2536 public RestClientBuilder dictionaryReplace(Class<?>...values) { 2537 super.dictionaryReplace(values); 2538 return this; 2539 } 2540 2541 @Override /* BeanContextBuilder */ 2542 public RestClientBuilder dictionaryReplace(Object...values) { 2543 super.dictionaryReplace(values); 2544 return this; 2545 } 2546 2547 @Override /* BeanContextBuilder */ 2548 public RestClientBuilder dictionaryRemove(Class<?>...values) { 2549 super.dictionaryRemove(values); 2550 return this; 2551 } 2552 2553 @Override /* BeanContextBuilder */ 2554 public RestClientBuilder dictionaryRemove(Object...values) { 2555 super.dictionaryRemove(values); 2556 return this; 2557 } 2558 2559 @Override /* BeanContextBuilder */ 2560 public <T> RestClientBuilder example(Class<T> c, T o) { 2561 super.example(c, o); 2562 return this; 2563 } 2564 2565 @Override /* BeanContextBuilder */ 2566 public <T> RestClientBuilder exampleJson(Class<T> c, String value) { 2567 super.exampleJson(c, value); 2568 return this; 2569 } 2570 2571 @Override /* BeanContextBuilder */ 2572 public RestClientBuilder ignoreInvocationExceptionsOnGetters(boolean value) { 2573 super.ignoreInvocationExceptionsOnGetters(value); 2574 return this; 2575 } 2576 2577 @Override /* BeanContextBuilder */ 2578 public RestClientBuilder ignoreInvocationExceptionsOnGetters() { 2579 super.ignoreInvocationExceptionsOnGetters(); 2580 return this; 2581 } 2582 2583 @Override /* BeanContextBuilder */ 2584 public RestClientBuilder ignoreInvocationExceptionsOnSetters(boolean value) { 2585 super.ignoreInvocationExceptionsOnSetters(value); 2586 return this; 2587 } 2588 2589 @Override /* BeanContextBuilder */ 2590 public RestClientBuilder ignoreInvocationExceptionsOnSetters() { 2591 super.ignoreInvocationExceptionsOnSetters(); 2592 return this; 2593 } 2594 2595 @Override /* BeanContextBuilder */ 2596 public RestClientBuilder ignorePropertiesWithoutSetters(boolean value) { 2597 super.ignorePropertiesWithoutSetters(value); 2598 return this; 2599 } 2600 2601 @Override /* BeanContextBuilder */ 2602 public RestClientBuilder ignoreUnknownBeanProperties(boolean value) { 2603 super.ignoreUnknownBeanProperties(value); 2604 return this; 2605 } 2606 2607 @Override /* BeanContextBuilder */ 2608 public RestClientBuilder ignoreUnknownBeanProperties() { 2609 super.ignoreUnknownBeanProperties(); 2610 return this; 2611 } 2612 2613 @Override /* BeanContextBuilder */ 2614 public RestClientBuilder ignoreUnknownNullBeanProperties(boolean value) { 2615 super.ignoreUnknownNullBeanProperties(value); 2616 return this; 2617 } 2618 2619 @Override /* BeanContextBuilder */ 2620 public RestClientBuilder implClass(Class<?> interfaceClass, Class<?> implClass) { 2621 super.implClass(interfaceClass, implClass); 2622 return this; 2623 } 2624 2625 @Override /* BeanContextBuilder */ 2626 public RestClientBuilder implClasses(Map<String,Class<?>> values) { 2627 super.implClasses(values); 2628 return this; 2629 } 2630 2631 @Override /* BeanContextBuilder */ 2632 public RestClientBuilder locale(Locale value) { 2633 super.locale(value); 2634 return this; 2635 } 2636 2637 @Override /* BeanContextBuilder */ 2638 public RestClientBuilder mediaType(MediaType value) { 2639 super.mediaType(value); 2640 return this; 2641 } 2642 2643 @Override /* BeanContextBuilder */ 2644 public RestClientBuilder notBeanClasses(Class<?>...values) { 2645 super.notBeanClasses(values); 2646 return this; 2647 } 2648 2649 @Override /* BeanContextBuilder */ 2650 public RestClientBuilder notBeanClasses(Object...values) { 2651 super.notBeanClasses(values); 2652 return this; 2653 } 2654 2655 @Override /* BeanContextBuilder */ 2656 public RestClientBuilder notBeanClassesReplace(Class<?>...values) { 2657 super.notBeanClassesReplace(values); 2658 return this; 2659 } 2660 2661 @Override /* BeanContextBuilder */ 2662 public RestClientBuilder notBeanClassesReplace(Object...values) { 2663 super.notBeanClassesReplace(values); 2664 return this; 2665 } 2666 2667 @Override /* BeanContextBuilder */ 2668 public RestClientBuilder notBeanClassesRemove(Class<?>...values) { 2669 super.notBeanClassesRemove(values); 2670 return this; 2671 } 2672 2673 @Override /* BeanContextBuilder */ 2674 public RestClientBuilder notBeanClassesRemove(Object...values) { 2675 super.notBeanClassesRemove(values); 2676 return this; 2677 } 2678 2679 @Override /* BeanContextBuilder */ 2680 public RestClientBuilder notBeanPackages(Object...values) { 2681 super.notBeanPackages(values); 2682 return this; 2683 } 2684 2685 @Override /* BeanContextBuilder */ 2686 public RestClientBuilder notBeanPackages(String...values) { 2687 super.notBeanPackages(values); 2688 return this; 2689 } 2690 2691 @Override /* BeanContextBuilder */ 2692 public RestClientBuilder notBeanPackagesReplace(String...values) { 2693 super.notBeanPackagesReplace(values); 2694 return this; 2695 } 2696 2697 @Override /* BeanContextBuilder */ 2698 public RestClientBuilder notBeanPackagesReplace(Object...values) { 2699 super.notBeanPackagesReplace(values); 2700 return this; 2701 } 2702 2703 @Override /* BeanContextBuilder */ 2704 public RestClientBuilder notBeanPackagesRemove(String...values) { 2705 super.notBeanPackagesRemove(values); 2706 return this; 2707 } 2708 2709 @Override /* BeanContextBuilder */ 2710 public RestClientBuilder notBeanPackagesRemove(Object...values) { 2711 super.notBeanPackagesRemove(values); 2712 return this; 2713 } 2714 2715 @Override /* BeanContextBuilder */ 2716 public RestClientBuilder pojoSwaps(Class<?>...values) { 2717 super.pojoSwaps(values); 2718 return this; 2719 } 2720 2721 @Override /* BeanContextBuilder */ 2722 public RestClientBuilder pojoSwaps(Object...values) { 2723 super.pojoSwaps(values); 2724 return this; 2725 } 2726 2727 @Override /* BeanContextBuilder */ 2728 public RestClientBuilder pojoSwapsReplace(Class<?>...values) { 2729 super.pojoSwapsReplace(values); 2730 return this; 2731 } 2732 2733 @Override /* BeanContextBuilder */ 2734 public RestClientBuilder pojoSwapsReplace(Object...values) { 2735 super.pojoSwapsReplace(values); 2736 return this; 2737 } 2738 2739 @Override /* BeanContextBuilder */ 2740 public RestClientBuilder pojoSwapsRemove(Class<?>...values) { 2741 super.pojoSwapsRemove(values); 2742 return this; 2743 } 2744 2745 @Override /* BeanContextBuilder */ 2746 public RestClientBuilder pojoSwapsRemove(Object...values) { 2747 super.pojoSwapsRemove(values); 2748 return this; 2749 } 2750 2751 @Override /* BeanContextBuilder */ 2752 public RestClientBuilder sortProperties(boolean value) { 2753 super.sortProperties(value); 2754 return this; 2755 } 2756 2757 @Override /* BeanContextBuilder */ 2758 public RestClientBuilder sortProperties() { 2759 super.sortProperties(); 2760 return this; 2761 } 2762 2763 @Override /* BeanContextBuilder */ 2764 public RestClientBuilder timeZone(TimeZone value) { 2765 super.timeZone(value); 2766 return this; 2767 } 2768 2769 @Override /* BeanContextBuilder */ 2770 public RestClientBuilder useEnumNames(boolean value) { 2771 super.useEnumNames(value); 2772 return this; 2773 } 2774 2775 @Override /* BeanContextBuilder */ 2776 public RestClientBuilder useEnumNames() { 2777 super.useEnumNames(); 2778 return this; 2779 } 2780 2781 @Override /* BeanContextBuilder */ 2782 public RestClientBuilder useInterfaceProxies(boolean value) { 2783 super.useInterfaceProxies(value); 2784 return this; 2785 } 2786 2787 @Override /* BeanContextBuilder */ 2788 public RestClientBuilder useJavaBeanIntrospector(boolean value) { 2789 super.useJavaBeanIntrospector(value); 2790 return this; 2791 } 2792 2793 @Override /* BeanContextBuilder */ 2794 public RestClientBuilder useJavaBeanIntrospector() { 2795 super.useJavaBeanIntrospector(); 2796 return this; 2797 } 2798 2799 @Override /* ContextBuilder */ 2800 public RestClientBuilder set(String name, Object value) { 2801 super.set(name, value); 2802 return this; 2803 } 2804 2805 @Override /* ContextBuilder */ 2806 public RestClientBuilder set(Map<String,Object> properties) { 2807 super.set(properties); 2808 return this; 2809 } 2810 2811 @Override /* ContextBuilder */ 2812 public RestClientBuilder add(Map<String,Object> properties) { 2813 super.add(properties); 2814 return this; 2815 } 2816 2817 @Override /* ContextBuilder */ 2818 public RestClientBuilder addTo(String name, Object value) { 2819 super.addTo(name, value); 2820 return this; 2821 } 2822 2823 @Override /* ContextBuilder */ 2824 public RestClientBuilder addTo(String name, String key, Object value) { 2825 super.addTo(name, key, value); 2826 return this; 2827 } 2828 2829 @Override /* ContextBuilder */ 2830 public RestClientBuilder removeFrom(String name, Object value) { 2831 super.removeFrom(name, value); 2832 return this; 2833 } 2834 2835 @Override /* ContextBuilder */ 2836 public RestClientBuilder apply(PropertyStore copyFrom) { 2837 super.apply(copyFrom); 2838 return this; 2839 } 2840 2841 @Override /* ContextBuilder */ 2842 public RestClientBuilder applyAnnotations(AnnotationList al, VarResolverSession vrs) { 2843 super.applyAnnotations(al, vrs); 2844 return this; 2845 } 2846 2847 @Override /* ContextBuilder */ 2848 public RestClientBuilder applyAnnotations(Class<?> fromClass) { 2849 super.applyAnnotations(fromClass); 2850 return this; 2851 } 2852 2853 @Override /* ContextBuilder */ 2854 public RestClientBuilder applyAnnotations(Method fromMethod) { 2855 super.applyAnnotations(fromMethod); 2856 return this; 2857 } 2858 2859 //------------------------------------------------------------------------------------------------ 2860 // Passthrough methods for HttpClientBuilder. 2861 //------------------------------------------------------------------------------------------------ 2862 2863 /** 2864 * @return This object (for method chaining). 2865 * @see HttpClientBuilder#disableRedirectHandling() 2866 */ 2867 public RestClientBuilder disableRedirectHandling() { 2868 httpClientBuilder.disableRedirectHandling(); 2869 return this; 2870 } 2871 2872 /** 2873 * @param redirectStrategy New property value. 2874 * @return This object (for method chaining). 2875 * @see HttpClientBuilder#setRedirectStrategy(RedirectStrategy) 2876 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setRedirectStrategy(RedirectStrategy)}. 2877 */ 2878 @Deprecated 2879 public RestClientBuilder redirectStrategy(RedirectStrategy redirectStrategy) { 2880 httpClientBuilder.setRedirectStrategy(redirectStrategy); 2881 return this; 2882 } 2883 2884 /** 2885 * @param cookieSpecRegistry New property value. 2886 * @return This object (for method chaining). 2887 * @see HttpClientBuilder#setDefaultCookieSpecRegistry(Lookup) 2888 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setDefaultCookieSpecRegistry(Lookup)}. 2889 */ 2890 @Deprecated 2891 public RestClientBuilder defaultCookieSpecRegistry(Lookup<CookieSpecProvider> cookieSpecRegistry) { 2892 httpClientBuilder.setDefaultCookieSpecRegistry(cookieSpecRegistry); 2893 return this; 2894 } 2895 2896 /** 2897 * @param requestExec New property value. 2898 * @return This object (for method chaining). 2899 * @see HttpClientBuilder#setRequestExecutor(HttpRequestExecutor) 2900 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setRequestExecutor(HttpRequestExecutor)}. 2901 */ 2902 @Deprecated 2903 public RestClientBuilder requestExecutor(HttpRequestExecutor requestExec) { 2904 httpClientBuilder.setRequestExecutor(requestExec); 2905 return this; 2906 } 2907 2908 /** 2909 * @param hostnameVerifier New property value. 2910 * @return This object (for method chaining). 2911 * @see HttpClientBuilder#setSSLHostnameVerifier(HostnameVerifier) 2912 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setSSLHostnameVerifier(HostnameVerifier)}. 2913 */ 2914 @Deprecated 2915 public RestClientBuilder sslHostnameVerifier(HostnameVerifier hostnameVerifier) { 2916 httpClientBuilder.setSSLHostnameVerifier(hostnameVerifier); 2917 return this; 2918 } 2919 2920 /** 2921 * @param publicSuffixMatcher New property value. 2922 * @return This object (for method chaining). 2923 * @see HttpClientBuilder#setPublicSuffixMatcher(PublicSuffixMatcher) 2924 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setPublicSuffixMatcher(PublicSuffixMatcher)}. 2925 */ 2926 @Deprecated 2927 public RestClientBuilder publicSuffixMatcher(PublicSuffixMatcher publicSuffixMatcher) { 2928 httpClientBuilder.setPublicSuffixMatcher(publicSuffixMatcher); 2929 return this; 2930 } 2931 2932 /** 2933 * @param sslContext New property value. 2934 * @return This object (for method chaining). 2935 * @see HttpClientBuilder#setSSLContext(SSLContext) 2936 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setSSLContext(SSLContext)}. 2937 */ 2938 @Deprecated 2939 public RestClientBuilder sslContext(SSLContext sslContext) { 2940 httpClientBuilder.setSSLContext(sslContext); 2941 return this; 2942 } 2943 2944 /** 2945 * @param sslSocketFactory New property value. 2946 * @return This object (for method chaining). 2947 * @see HttpClientBuilder#setSSLSocketFactory(LayeredConnectionSocketFactory) 2948 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setSSLSocketFactory(LayeredConnectionSocketFactory)}. 2949 */ 2950 @Deprecated 2951 public RestClientBuilder sslSocketFactory(LayeredConnectionSocketFactory sslSocketFactory) { 2952 httpClientBuilder.setSSLSocketFactory(sslSocketFactory); 2953 return this; 2954 } 2955 2956 /** 2957 * @param maxConnTotal New property value. 2958 * @return This object (for method chaining). 2959 * @see HttpClientBuilder#setMaxConnTotal(int) 2960 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setMaxConnTotal(int)}. 2961 */ 2962 @Deprecated 2963 public RestClientBuilder maxConnTotal(int maxConnTotal) { 2964 httpClientBuilder.setMaxConnTotal(maxConnTotal); 2965 return this; 2966 } 2967 2968 /** 2969 * @param maxConnPerRoute New property value. 2970 * @return This object (for method chaining). 2971 * @see HttpClientBuilder#setMaxConnPerRoute(int) 2972 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setMaxConnPerRoute(int)}. 2973 */ 2974 @Deprecated 2975 public RestClientBuilder maxConnPerRoute(int maxConnPerRoute) { 2976 httpClientBuilder.setMaxConnPerRoute(maxConnPerRoute); 2977 return this; 2978 } 2979 2980 /** 2981 * @param config New property value. 2982 * @return This object (for method chaining). 2983 * @see HttpClientBuilder#setDefaultSocketConfig(SocketConfig) 2984 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setDefaultSocketConfig(SocketConfig)}. 2985 */ 2986 @Deprecated 2987 public RestClientBuilder defaultSocketConfig(SocketConfig config) { 2988 httpClientBuilder.setDefaultSocketConfig(config); 2989 return this; 2990 } 2991 2992 /** 2993 * @param config New property value. 2994 * @return This object (for method chaining). 2995 * @see HttpClientBuilder#setDefaultConnectionConfig(ConnectionConfig) 2996 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setDefaultConnectionConfig(ConnectionConfig)}. 2997 */ 2998 @Deprecated 2999 public RestClientBuilder defaultConnectionConfig(ConnectionConfig config) { 3000 httpClientBuilder.setDefaultConnectionConfig(config); 3001 return this; 3002 } 3003 3004 /** 3005 * @param connTimeToLive New property value. 3006 * @param connTimeToLiveTimeUnit New property value. 3007 * @return This object (for method chaining). 3008 * @see HttpClientBuilder#setConnectionTimeToLive(long,TimeUnit) 3009 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setConnectionTimeToLive(long, TimeUnit)}. 3010 */ 3011 @Deprecated 3012 public RestClientBuilder connectionTimeToLive(long connTimeToLive, TimeUnit connTimeToLiveTimeUnit) { 3013 httpClientBuilder.setConnectionTimeToLive(connTimeToLive, connTimeToLiveTimeUnit); 3014 return this; 3015 } 3016 3017 /** 3018 * @param connManager New property value. 3019 * @return This object (for method chaining). 3020 * @see HttpClientBuilder#setConnectionManager(HttpClientConnectionManager) 3021 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setConnectionManager(HttpClientConnectionManager)}. 3022 */ 3023 @Deprecated 3024 public RestClientBuilder connectionManager(HttpClientConnectionManager connManager) { 3025 this.httpClientConnectionManager = connManager; 3026 httpClientBuilder.setConnectionManager(connManager); 3027 return this; 3028 } 3029 3030 /** 3031 * @param shared New property value. 3032 * @return This object (for method chaining). 3033 * @see HttpClientBuilder#setConnectionManagerShared(boolean) 3034 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setConnectionManagerShared(boolean)}. 3035 */ 3036 @Deprecated 3037 public RestClientBuilder connectionManagerShared(boolean shared) { 3038 httpClientBuilder.setConnectionManagerShared(shared); 3039 return this; 3040 } 3041 3042 /** 3043 * @param reuseStrategy New property value. 3044 * @return This object (for method chaining). 3045 * @see HttpClientBuilder#setConnectionReuseStrategy(ConnectionReuseStrategy) 3046 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setConnectionReuseStrategy(ConnectionReuseStrategy)}. 3047 */ 3048 @Deprecated 3049 public RestClientBuilder connectionReuseStrategy(ConnectionReuseStrategy reuseStrategy) { 3050 httpClientBuilder.setConnectionReuseStrategy(reuseStrategy); 3051 return this; 3052 } 3053 3054 /** 3055 * @param keepAliveStrategy New property value. 3056 * @return This object (for method chaining). 3057 * @see HttpClientBuilder#setKeepAliveStrategy(ConnectionKeepAliveStrategy) 3058 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setKeepAliveStrategy(ConnectionKeepAliveStrategy)}. 3059 */ 3060 @Deprecated 3061 public RestClientBuilder keepAliveStrategy(ConnectionKeepAliveStrategy keepAliveStrategy) { 3062 httpClientBuilder.setKeepAliveStrategy(keepAliveStrategy); 3063 return this; 3064 } 3065 3066 /** 3067 * @param targetAuthStrategy New property value. 3068 * @return This object (for method chaining). 3069 * @see HttpClientBuilder#setTargetAuthenticationStrategy(AuthenticationStrategy) 3070 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setTargetAuthenticationStrategy(AuthenticationStrategy)}. 3071 */ 3072 @Deprecated 3073 public RestClientBuilder targetAuthenticationStrategy(AuthenticationStrategy targetAuthStrategy) { 3074 httpClientBuilder.setTargetAuthenticationStrategy(targetAuthStrategy); 3075 return this; 3076 } 3077 3078 /** 3079 * @param proxyAuthStrategy New property value. 3080 * @return This object (for method chaining). 3081 * @see HttpClientBuilder#setProxyAuthenticationStrategy(AuthenticationStrategy) 3082 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setProxyAuthenticationStrategy(AuthenticationStrategy)}. 3083 */ 3084 @Deprecated 3085 public RestClientBuilder proxyAuthenticationStrategy(AuthenticationStrategy proxyAuthStrategy) { 3086 httpClientBuilder.setProxyAuthenticationStrategy(proxyAuthStrategy); 3087 return this; 3088 } 3089 3090 /** 3091 * @param userTokenHandler New property value. 3092 * @return This object (for method chaining). 3093 * @see HttpClientBuilder#setUserTokenHandler(UserTokenHandler) 3094 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setUserTokenHandler(UserTokenHandler)}. 3095 */ 3096 @Deprecated 3097 public RestClientBuilder userTokenHandler(UserTokenHandler userTokenHandler) { 3098 httpClientBuilder.setUserTokenHandler(userTokenHandler); 3099 return this; 3100 } 3101 3102 /** 3103 * @return This object (for method chaining). 3104 * @see HttpClientBuilder#disableConnectionState() 3105 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#disableConnectionState()}. 3106 */ 3107 @Deprecated 3108 public RestClientBuilder disableConnectionState() { 3109 httpClientBuilder.disableConnectionState(); 3110 return this; 3111 } 3112 3113 /** 3114 * @param schemePortResolver New property value. 3115 * @return This object (for method chaining). 3116 * @see HttpClientBuilder#setSchemePortResolver(SchemePortResolver) 3117 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setSchemePortResolver(SchemePortResolver)}. 3118 */ 3119 @Deprecated 3120 public RestClientBuilder schemePortResolver(SchemePortResolver schemePortResolver) { 3121 httpClientBuilder.setSchemePortResolver(schemePortResolver); 3122 return this; 3123 } 3124 3125 /** 3126 * @param userAgent New property value. 3127 * @return This object (for method chaining). 3128 * @see HttpClientBuilder#setUserAgent(String) 3129 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setUserAgent(String)}. 3130 */ 3131 @Deprecated 3132 public RestClientBuilder userAgent(String userAgent) { 3133 httpClientBuilder.setUserAgent(userAgent); 3134 return this; 3135 } 3136 3137 /** 3138 * @param defaultHeaders New property value. 3139 * @return This object (for method chaining). 3140 * @see HttpClientBuilder#setDefaultHeaders(Collection) 3141 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setDefaultHeaders(Collection)}. 3142 */ 3143 @Deprecated 3144 public RestClientBuilder defaultHeaders(Collection<? extends Header> defaultHeaders) { 3145 httpClientBuilder.setDefaultHeaders(defaultHeaders); 3146 return this; 3147 } 3148 3149 /** 3150 * @param itcp New property value. 3151 * @return This object (for method chaining). 3152 * @see HttpClientBuilder#addInterceptorFirst(HttpResponseInterceptor) 3153 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#addInterceptorFirst(HttpResponseInterceptor)}. 3154 */ 3155 @Deprecated 3156 public RestClientBuilder addInterceptorFirst(HttpResponseInterceptor itcp) { 3157 httpClientBuilder.addInterceptorFirst(itcp); 3158 return this; 3159 } 3160 3161 /** 3162 * @param itcp New property value. 3163 * @return This object (for method chaining). 3164 * @see HttpClientBuilder#addInterceptorLast(HttpResponseInterceptor) 3165 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#addInterceptorLast(HttpResponseInterceptor)}. 3166 */ 3167 @Deprecated 3168 public RestClientBuilder addInterceptorLast(HttpResponseInterceptor itcp) { 3169 httpClientBuilder.addInterceptorLast(itcp); 3170 return this; 3171 } 3172 3173 /** 3174 * @param itcp New property value. 3175 * @return This object (for method chaining). 3176 * @see HttpClientBuilder#addInterceptorFirst(HttpRequestInterceptor) 3177 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#addInterceptorFirst(HttpRequestInterceptor)}. 3178 */ 3179 @Deprecated 3180 public RestClientBuilder addInterceptorFirst(HttpRequestInterceptor itcp) { 3181 httpClientBuilder.addInterceptorFirst(itcp); 3182 return this; 3183 } 3184 3185 /** 3186 * @param itcp New property value. 3187 * @return This object (for method chaining). 3188 * @see HttpClientBuilder#addInterceptorLast(HttpRequestInterceptor) 3189 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#addInterceptorLast(HttpRequestInterceptor)}. 3190 */ 3191 @Deprecated 3192 public RestClientBuilder addInterceptorLast(HttpRequestInterceptor itcp) { 3193 httpClientBuilder.addInterceptorLast(itcp); 3194 return this; 3195 } 3196 3197 /** 3198 * @return This object (for method chaining). 3199 * @see HttpClientBuilder#disableCookieManagement() 3200 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#disableCookieManagement()}. 3201 */ 3202 @Deprecated 3203 public RestClientBuilder disableCookieManagement() { 3204 httpClientBuilder.disableCookieManagement(); 3205 return this; 3206 } 3207 3208 /** 3209 * @return This object (for method chaining). 3210 * @see HttpClientBuilder#disableContentCompression() 3211 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#disableContentCompression()}. 3212 */ 3213 @Deprecated 3214 public RestClientBuilder disableContentCompression() { 3215 httpClientBuilder.disableContentCompression(); 3216 return this; 3217 } 3218 3219 /** 3220 * @return This object (for method chaining). 3221 * @see HttpClientBuilder#disableAuthCaching() 3222 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#disableAuthCaching()}. 3223 */ 3224 @Deprecated 3225 public RestClientBuilder disableAuthCaching() { 3226 httpClientBuilder.disableAuthCaching(); 3227 return this; 3228 } 3229 3230 /** 3231 * @param httpprocessor New property value. 3232 * @return This object (for method chaining). 3233 * @see HttpClientBuilder#setHttpProcessor(HttpProcessor) 3234 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setHttpProcessor(HttpProcessor)}. 3235 */ 3236 @Deprecated 3237 public RestClientBuilder httpProcessor(HttpProcessor httpprocessor) { 3238 httpClientBuilder.setHttpProcessor(httpprocessor); 3239 return this; 3240 } 3241 3242 /** 3243 * @param retryHandler New property value. 3244 * @return This object (for method chaining). 3245 * @see HttpClientBuilder#setRetryHandler(HttpRequestRetryHandler) 3246 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setRetryHandler(HttpRequestRetryHandler)}. 3247 */ 3248 @Deprecated 3249 public RestClientBuilder retryHandler(HttpRequestRetryHandler retryHandler) { 3250 httpClientBuilder.setRetryHandler(retryHandler); 3251 return this; 3252 } 3253 3254 /** 3255 * @return This object (for method chaining). 3256 * @see HttpClientBuilder#disableAutomaticRetries() 3257 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#disableAutomaticRetries()}. 3258 */ 3259 @Deprecated 3260 public RestClientBuilder disableAutomaticRetries() { 3261 httpClientBuilder.disableAutomaticRetries(); 3262 return this; 3263 } 3264 3265 /** 3266 * @param proxy New property value. 3267 * @return This object (for method chaining). 3268 * @see HttpClientBuilder#setProxy(HttpHost) 3269 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setProxy(HttpHost)}. 3270 */ 3271 @Deprecated 3272 public RestClientBuilder proxy(HttpHost proxy) { 3273 httpClientBuilder.setProxy(proxy); 3274 return this; 3275 } 3276 3277 /** 3278 * @param routePlanner New property value. 3279 * @return This object (for method chaining). 3280 * @see HttpClientBuilder#setRoutePlanner(HttpRoutePlanner) 3281 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setRoutePlanner(HttpRoutePlanner)}. 3282 */ 3283 @Deprecated 3284 public RestClientBuilder routePlanner(HttpRoutePlanner routePlanner) { 3285 httpClientBuilder.setRoutePlanner(routePlanner); 3286 return this; 3287 } 3288 3289 /** 3290 * @param connectionBackoffStrategy New property value. 3291 * @return This object (for method chaining). 3292 * @see HttpClientBuilder#setConnectionBackoffStrategy(ConnectionBackoffStrategy) 3293 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setConnectionBackoffStrategy(ConnectionBackoffStrategy)}. 3294 */ 3295 @Deprecated 3296 public RestClientBuilder connectionBackoffStrategy(ConnectionBackoffStrategy connectionBackoffStrategy) { 3297 httpClientBuilder.setConnectionBackoffStrategy(connectionBackoffStrategy); 3298 return this; 3299 } 3300 3301 /** 3302 * @param backoffManager New property value. 3303 * @return This object (for method chaining). 3304 * @see HttpClientBuilder#setBackoffManager(BackoffManager) 3305 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setBackoffManager(BackoffManager)}. 3306 */ 3307 @Deprecated 3308 public RestClientBuilder backoffManager(BackoffManager backoffManager) { 3309 httpClientBuilder.setBackoffManager(backoffManager); 3310 return this; 3311 } 3312 3313 /** 3314 * @param serviceUnavailStrategy New property value. 3315 * @return This object (for method chaining). 3316 * @see HttpClientBuilder#setServiceUnavailableRetryStrategy(ServiceUnavailableRetryStrategy) 3317 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setServiceUnavailableRetryStrategy(ServiceUnavailableRetryStrategy)}. 3318 */ 3319 @Deprecated 3320 public RestClientBuilder serviceUnavailableRetryStrategy(ServiceUnavailableRetryStrategy serviceUnavailStrategy) { 3321 httpClientBuilder.setServiceUnavailableRetryStrategy(serviceUnavailStrategy); 3322 return this; 3323 } 3324 3325 /** 3326 * @param cookieStore New property value. 3327 * @return This object (for method chaining). 3328 * @see HttpClientBuilder#setDefaultCookieStore(CookieStore) 3329 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setDefaultCookieStore(CookieStore)}. 3330 */ 3331 @Deprecated 3332 public RestClientBuilder defaultCookieStore(CookieStore cookieStore) { 3333 httpClientBuilder.setDefaultCookieStore(cookieStore); 3334 return this; 3335 } 3336 3337 /** 3338 * @param credentialsProvider New property value. 3339 * @return This object (for method chaining). 3340 * @see HttpClientBuilder#setDefaultCredentialsProvider(CredentialsProvider) 3341 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setDefaultCredentialsProvider(CredentialsProvider)}. 3342 */ 3343 @Deprecated 3344 public RestClientBuilder defaultCredentialsProvider(CredentialsProvider credentialsProvider) { 3345 httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider); 3346 return this; 3347 } 3348 3349 /** 3350 * @param authSchemeRegistry New property value. 3351 * @return This object (for method chaining). 3352 * @see HttpClientBuilder#setDefaultAuthSchemeRegistry(Lookup) 3353 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setDefaultAuthSchemeRegistry(Lookup)}. 3354 */ 3355 @Deprecated 3356 public RestClientBuilder defaultAuthSchemeRegistry(Lookup<AuthSchemeProvider> authSchemeRegistry) { 3357 httpClientBuilder.setDefaultAuthSchemeRegistry(authSchemeRegistry); 3358 return this; 3359 } 3360 3361 /** 3362 * @param contentDecoderMap New property value. 3363 * @return This object (for method chaining). 3364 * @see HttpClientBuilder#setContentDecoderRegistry(Map) 3365 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setContentDecoderRegistry(Map)}. 3366 */ 3367 @Deprecated 3368 public RestClientBuilder contentDecoderRegistry(Map<String,InputStreamFactory> contentDecoderMap) { 3369 httpClientBuilder.setContentDecoderRegistry(contentDecoderMap); 3370 return this; 3371 } 3372 3373 /** 3374 * @param config New property value. 3375 * @return This object (for method chaining). 3376 * @see HttpClientBuilder#setDefaultRequestConfig(RequestConfig) 3377 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#setDefaultRequestConfig(RequestConfig)}. 3378 */ 3379 @Deprecated 3380 public RestClientBuilder defaultRequestConfig(RequestConfig config) { 3381 httpClientBuilder.setDefaultRequestConfig(config); 3382 return this; 3383 } 3384 3385 /** 3386 * @return This object (for method chaining). 3387 * @see HttpClientBuilder#useSystemProperties() 3388 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#useSystemProperties()}. 3389 */ 3390 @Deprecated 3391 public RestClientBuilder useSystemProperties() { 3392 httpClientBuilder.useSystemProperties(); 3393 return this; 3394 } 3395 3396 /** 3397 * @return This object (for method chaining). 3398 * @see HttpClientBuilder#evictExpiredConnections() 3399 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#evictExpiredConnections()}. 3400 */ 3401 @Deprecated 3402 public RestClientBuilder evictExpiredConnections() { 3403 httpClientBuilder.evictExpiredConnections(); 3404 return this; 3405 } 3406 3407 /** 3408 * @param maxIdleTime New property value. 3409 * @param maxIdleTimeUnit New property value. 3410 * @return This object (for method chaining). 3411 * @see HttpClientBuilder#evictIdleConnections(long,TimeUnit) 3412 * @deprecated Use {@link #getHttpClientBuilder()} and {@link HttpClientBuilder#evictIdleConnections(long, TimeUnit)}. 3413 */ 3414 @Deprecated 3415 public RestClientBuilder evictIdleConnections(long maxIdleTime, TimeUnit maxIdleTimeUnit) { 3416 httpClientBuilder.evictIdleConnections(maxIdleTime, maxIdleTimeUnit); 3417 return this; 3418 } 3419}