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