http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClientBuilder.java ---------------------------------------------------------------------- diff --git a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClientBuilder.java b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClientBuilder.java new file mode 100644 index 0000000..bacbe66 --- /dev/null +++ b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClientBuilder.java @@ -0,0 +1,1864 @@ +// *************************************************************************************************************************** +// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * +// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * +// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * +// * with the License. You may obtain a copy of the License at * +// * * +// * http://www.apache.org/licenses/LICENSE-2.0 * +// * * +// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * +// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * +// * specific language governing permissions and limitations under the License. * +// *************************************************************************************************************************** +package org.apache.juneau.rest.client; + +import static org.apache.juneau.parser.ParserContext.*; +import static org.apache.juneau.serializer.SerializerContext.*; + +import java.lang.reflect.*; +import java.net.*; +import java.security.*; +import java.util.*; +import java.util.concurrent.*; +import java.util.logging.*; + +import javax.net.ssl.*; + +import org.apache.http.*; +import org.apache.http.auth.*; +import org.apache.http.client.*; +import org.apache.http.client.CookieStore; +import org.apache.http.client.config.*; +import org.apache.http.client.entity.*; +import org.apache.http.config.*; +import org.apache.http.conn.*; +import org.apache.http.conn.routing.*; +import org.apache.http.conn.socket.*; +import org.apache.http.conn.ssl.*; +import org.apache.http.conn.util.*; +import org.apache.http.cookie.*; +import org.apache.http.impl.client.*; +import org.apache.http.impl.conn.*; +import org.apache.http.protocol.*; +import org.apache.juneau.*; +import org.apache.juneau.internal.*; +import org.apache.juneau.json.*; +import org.apache.juneau.parser.*; +import org.apache.juneau.serializer.*; +import org.apache.juneau.urlencoding.*; + +/** + * Builder class for {@link RestClient} class. + */ +@SuppressWarnings("hiding") +public class RestClientBuilder extends CoreObjectBuilder { + + private HttpClientConnectionManager httpClientConnectionManager; + private HttpClientBuilder httpClientBuilder = createHttpClientBuilder(); + private CloseableHttpClient httpClient; + private boolean keepHttpClientOpen; + + private Class<? extends Serializer> serializerClass = JsonSerializer.class; + private Class<? extends Parser> parserClass = JsonParser.class; + private Serializer serializer; + private Parser parser; + + private Map<String,String> headers = new TreeMap<String,String>(String.CASE_INSENSITIVE_ORDER); + + private List<RestCallInterceptor> interceptors = new ArrayList<RestCallInterceptor>(); + + private String remoteableServletUri; + private Map<Method,String> remoteableServiceUriMap = new ConcurrentHashMap<Method,String>(); + private String rootUrl; + private SSLOpts sslOpts; + private boolean pooled; + + private int retries = 1; + private long retryInterval = -1; + private RetryOn retryOn = RetryOn.DEFAULT; + + /** + * Constructor, default settings. + */ + public RestClientBuilder() { + super(); + } + + /** + * Constructor, default settings. + * <p> + * Shortcut for calling <code><jk>new</jk> RestClientBuilder().serializer(s).parser(p);</code> + * + * @param s The serializer to use for output. + * @param p The parser to use for input. + */ + public RestClientBuilder(Serializer s, Parser p) { + super(); + serializer(s); + parser(p); + } + + /** + * Constructor, default settings. + * <p> + * Shortcut for calling <code><jk>new</jk> RestClientBuilder().serializer(s).parser(p);</code> + * + * @param s The serializer class to use for output. + * @param p The parser class to use for input. + */ + public RestClientBuilder(Class<? extends Serializer> s, Class<? extends Parser> p) { + super(); + serializer(s); + parser(p); + } + + /** + * Constructor. + * @param propertyStore The initial configuration settings for this builder. + */ + public RestClientBuilder(PropertyStore propertyStore) { + super(propertyStore); + } + + @Override /* CoreObjectBuilder */ + public RestClient build() { + try { + CloseableHttpClient httpClient = this.httpClient; + if (httpClient == null) + httpClient = createHttpClient(); + + Serializer s = + this.serializer != null + ? this.serializer.builder().apply(propertyStore).build() + : new SerializerBuilder(propertyStore).build(this.serializerClass); + + Parser p = + this.parser != null + ? this.parser.builder().apply(propertyStore).build() + : new ParserBuilder(propertyStore).build(this.parserClass); + + UrlEncodingSerializer us = new SerializerBuilder(propertyStore).build(UrlEncodingSerializer.class); + + return new RestClient(propertyStore, httpClient, keepHttpClientOpen, s, p, us, headers, interceptors, remoteableServletUri, remoteableServiceUriMap, rootUrl, retryOn, retries, retryInterval); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + /** + * Creates an instance of an {@link HttpClient} to be used to handle all HTTP communications with the target server. + * <p> + * This HTTP client is used when the HTTP client is not specified through one of the constructors or the + * {@link #httpClient(CloseableHttpClient, boolean)} method. + * <p> + * Subclasses can override this method to provide specially-configured HTTP clients to handle + * stuff such as SSL/TLS certificate handling, authentication, etc. + * <p> + * The default implementation returns an instance of {@link HttpClient} using the client builder + * returned by {@link #createHttpClientBuilder()}. + * + * @return The HTTP client to use. + * @throws Exception + */ + protected CloseableHttpClient createHttpClient() throws Exception { + // Don't call createConnectionManager() if RestClient.setConnectionManager() was called. + if (httpClientConnectionManager == null) + httpClientBuilder.setConnectionManager(createConnectionManager()); + return httpClientBuilder.build(); + } + + /** + * Creates an instance of an {@link HttpClientBuilder} to be used to create + * the {@link HttpClient}. + * <p> + * Subclasses can override this method to provide their own client builder. + * <p> + * The predefined method returns an {@link HttpClientBuilder} with the following settings: + * <ul> + * <li>Lax redirect strategy. + * <li>The connection manager returned by {@link #createConnectionManager()}. + * </ul> + * + * @return The HTTP client builder to use to create the HTTP client. + */ + protected HttpClientBuilder createHttpClientBuilder() { + HttpClientBuilder b = HttpClientBuilder.create(); + b.setRedirectStrategy(new AllowAllRedirects()); + return b; + } + + /** + * Creates the {@link HttpClientConnectionManager} returned by {@link #createConnectionManager()}. + * <p> + * Subclasses can override this method to provide their own connection manager. + * <p> + * The default implementation returns an instance of a {@link PoolingHttpClientConnectionManager}. + * + * @return The HTTP client builder to use to create the HTTP client. + */ + protected HttpClientConnectionManager createConnectionManager() { + if (sslOpts != null) { + HostnameVerifier hv = null; + switch (sslOpts.getHostVerify()) { + case LAX: hv = new NoopHostnameVerifier(); break; + case DEFAULT: hv = new DefaultHostnameVerifier(); break; + } + + for (String p : StringUtils.split(sslOpts.getProtocols(), ',')) { + try { + TrustManager tm = new SimpleX509TrustManager(sslOpts.getCertValidate() == SSLOpts.CertValidate.LAX); + + SSLContext ctx = SSLContext.getInstance(p); + ctx.init(null, new TrustManager[] { tm }, null); + + // Create a socket to ensure this algorithm is acceptable. + // This will correctly disallow certain configurations (such as SSL_TLS under FIPS) + ctx.getSocketFactory().createSocket().close(); + SSLConnectionSocketFactory sf = new SSLConnectionSocketFactory(ctx, hv); + setSSLSocketFactory(sf); + + Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory> create().register("https", sf).build(); + + return (pooled ? new PoolingHttpClientConnectionManager(r) : new BasicHttpClientConnectionManager(r)); + } catch (Throwable t) {} + } + } + + // Using pooling connection so that this client is threadsafe. + return (pooled ? new PoolingHttpClientConnectionManager() : new BasicHttpClientConnectionManager()); + } + + /** + * Sets the URI of the remoteable services REST servlet for invoking remoteable services. + * + * @param remoteableServletUri The URI of the REST resource implementing a remoteable services servlet. + * (typically an instance of <code>RemoteableServlet</code>). + * @return This object (for method chaining). + */ + public RestClientBuilder remoteableServletUri(String remoteableServletUri) { + this.remoteableServletUri = remoteableServletUri; + return this; + } + + /** + * Set a root URL for this client. + * <p> + * When set, URL strings passed in through the various rest call methods (e.g. {@link RestClient#doGet(Object)} + * will be prefixed with the specified root. + * This root URL is ignored on those methods if you pass in a {@link URL}, {@link URI}, or an absolute URL string. + * + * @param rootUrl The root URL to prefix to relative URL strings. Trailing slashes are trimmed. + * Usually a <code>String<code> but you can also pass in <code>URI</code> and <code>URL</code> objects as well. + * @return This object (for method chaining). + */ + public RestClientBuilder rootUrl(Object rootUrl) { + String s = rootUrl.toString(); + if (s.endsWith("/")) + s = s.replaceAll("\\/$", ""); + this.rootUrl = s; + return this; + } + + /** + * Enable SSL support on this client. + * + * @param opts The SSL configuration options. See {@link SSLOpts} for details. + * This method is a no-op if <code>sslConfig</code> is <jk>null</jk>. + * @return This object (for method chaining). + * @throws KeyStoreException + * @throws NoSuchAlgorithmException + */ + public RestClientBuilder enableSSL(SSLOpts opts) throws KeyStoreException, NoSuchAlgorithmException { + this.sslOpts = opts; + return this; + } + + /** + * Enable LAX SSL support. + * <p> + * Certificate chain validation and hostname verification is disabled. + * + * @return This object (for method chaining). + * @throws KeyStoreException + * @throws NoSuchAlgorithmException + */ + public RestClientBuilder enableLaxSSL() throws KeyStoreException, NoSuchAlgorithmException { + return enableSSL(SSLOpts.LAX); + } + + /** + * Sets the client version by setting the value for the <js>"X-Client-Version"</js> header. + * + * @param version The version string (e.g. <js>"1.2.3"</js>) + * @return This object (for method chaining). + */ + public RestClientBuilder clientVersion(String version) { + return header("X-Client-Version", version); + } + + /** + * Adds an interceptor that gets called immediately after a connection is made. + * + * @param interceptor The interceptor. + * @return This object (for method chaining). + */ + public RestClientBuilder interceptor(RestCallInterceptor interceptor) { + interceptors.add(interceptor); + return this; + } + + /** + * Adds a {@link RestCallLogger} to the list of interceptors on this class. + * + * @param level The log level to log messsages at. + * @param log The logger to log messages to. + * @return This object (for method chaining). + */ + public RestClientBuilder logTo(Level level, Logger log) { + interceptor(new RestCallLogger(level, log)); + return this; + } + + /** + * Make HTTP calls retryable if an error response (>=400) is received. + * + * @param retries The number of retries to attempt. + * @param interval The time in milliseconds between attempts. + * @param retryOn Optional object used for determining whether a retry should be attempted. + * If <jk>null</jk>, uses {@link RetryOn#DEFAULT}. + * @return This object (for method chaining). + */ + public RestClientBuilder retryable(int retries, long interval, RetryOn retryOn) { + this.retries = retries; + this.retryInterval = interval; + this.retryOn = retryOn; + return this; + } + + /** + * When called, the {@link #createConnectionManager()} method will return a {@link PoolingHttpClientConnectionManager} + * instead of a {@link BasicHttpClientConnectionManager}. + * + * @return This object (for method chaining). + */ + public RestClientBuilder pooled() { + this.pooled = true; + return this; + } + + /** + * Sets the serializer used for serializing POJOs to the HTTP request message body. + * + * @param serializer The serializer. + * @return This object (for method chaining). + */ + public RestClientBuilder serializer(Serializer serializer) { + this.serializer = serializer; + return this; + } + + /** + * Same as {@link #serializer(Serializer)}, except takes in a serializer class that + * will be instantiated through a no-arg constructor. + * + * @param serializerClass The serializer class. + * @return This object (for method chaining). + */ + public RestClientBuilder serializer(Class<? extends Serializer> serializerClass) { + this.serializerClass = serializerClass; + return this; + } + + /** + * Sets the parser used for parsing POJOs from the HTTP response message body. + * + * @param parser The parser. + * @return This object (for method chaining). + */ + public RestClientBuilder parser(Parser parser) { + this.parser = parser; + return this; + } + + /** + * Same as {@link #parser(Parser)}, except takes in a parser class that + * will be instantiated through a no-arg constructor. + * + * @param parserClass The parser class. + * @return This object (for method chaining). + */ + public RestClientBuilder parser(Class<? extends Parser> parserClass) { + this.parserClass = parserClass; + return this; + } + + /** + * Set up this client to use BASIC auth. + * + * @param host The auth scope hostname. + * @param port The auth scope port. + * @param user The username. + * @param pw The password. + * @return This object (for method chaining). + */ + public RestClientBuilder basicAuth(String host, int port, String user, String pw) { + AuthScope scope = new AuthScope(host, port); + Credentials up = new UsernamePasswordCredentials(user, pw); + CredentialsProvider p = new BasicCredentialsProvider(); + p.setCredentials(scope, up); + setDefaultCredentialsProvider(p); + return this; + } + + /** + * Sets the internal {@link HttpClient} to use for handling HTTP communications. + * + * @param httpClient The HTTP client. + * @param keepHttpClientOpen Don't close this client when the {@link RestClient#close()} method is called. + * @return This object (for method chaining). + */ + public RestClientBuilder httpClient(CloseableHttpClient httpClient, boolean keepHttpClientOpen) { + this.httpClient = httpClient; + this.keepHttpClientOpen = keepHttpClientOpen; + return this; + } + + + //-------------------------------------------------------------------------------- + // HTTP headers + //-------------------------------------------------------------------------------- + + /** + * Specifies a request header property to add to all requests created by this client. + * + * @param name The HTTP header name. + * @param value The HTTP header value. + * @return This object (for method chaining). + */ + public RestClientBuilder header(String name, Object value) { + this.headers.put(name, value == null ? null : value.toString()); + return this; + } + + /** + * Sets the value for the <code>Accept</code> request header. + * <p> + * This overrides the media type specified on the parser, but is overridden by calling <code>header(<js>"Accept"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder accept(Object value) { + return header("Accept", value); + } + + /** + * Sets the value for the <code>Accept-Charset</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Accept-Charset"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder acceptCharset(Object value) { + return header("Accept-Charset", value); + } + + /** + * Sets the value for the <code>Accept-Encoding</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Accept-Encoding"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder acceptEncoding(Object value) { + return header("Accept-Encoding", value); + } + + /** + * Sets the value for the <code>Accept-Language</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Accept-Language"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder acceptLanguage(Object value) { + return header("Accept-Language", value); + } + + /** + * Sets the value for the <code>Authorization</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Authorization"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder authorization(Object value) { + return header("Authorization", value); + } + + /** + * Sets the value for the <code>Cache-Control</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Cache-Control"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder cacheControl(Object value) { + return header("Cache-Control", value); + } + + /** + * Sets the value for the <code>Connection</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Connection"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder connection(Object value) { + return header("Connection", value); + } + + /** + * Sets the value for the <code>Content-Length</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Content-Length"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder contentLength(Object value) { + return header("Content-Length", value); + } + + /** + * Sets the value for the <code>Content-Type</code> request header. + * <p> + * This overrides the media type specified on the serializer, but is overridden by calling <code>header(<js>"Content-Type"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder contentType(Object value) { + return header("Content-Type", value); + } + + /** + * Sets the value for the <code>Date</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Date"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder date(Object value) { + return header("Date", value); + } + + /** + * Sets the value for the <code>Expect</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Expect"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder expect(Object value) { + return header("Expect", value); + } + + /** + * Sets the value for the <code>Forwarded</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Forwarded"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder forwarded(Object value) { + return header("Forwarded", value); + } + + /** + * Sets the value for the <code>From</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"From"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder from(Object value) { + return header("From", value); + } + + /** + * Sets the value for the <code>Host</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Host"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder host(Object value) { + return header("Host", value); + } + + /** + * Sets the value for the <code>If-Match</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"If-Match"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder ifMatch(Object value) { + return header("If-Match", value); + } + + /** + * Sets the value for the <code>If-Modified-Since</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"If-Modified-Since"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder ifModifiedSince(Object value) { + return header("If-Modified-Since", value); + } + + /** + * Sets the value for the <code>If-None-Match</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"If-None-Match"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder ifNoneMatch(Object value) { + return header("If-None-Match", value); + } + + /** + * Sets the value for the <code>If-Range</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"If-Range"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder ifRange(Object value) { + return header("If-Range", value); + } + + /** + * Sets the value for the <code>If-Unmodified-Since</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"If-Unmodified-Since"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder ifUnmodifiedSince(Object value) { + return header("If-Unmodified-Since", value); + } + + /** + * Sets the value for the <code>Max-Forwards</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Max-Forwards"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder maxForwards(Object value) { + return header("If-Unmodified-Since", value); + } + + /** + * Sets the value for the <code>Origin</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Origin"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder origin(Object value) { + return header("If-Unmodified-Since", value); + } + + /** + * Sets the value for the <code>Pragma</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Pragma"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder pragma(Object value) { + return header("Pragma", value); + } + + /** + * Sets the value for the <code>Proxy-Authorization</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Proxy-Authorization"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder proxyAuthorization(Object value) { + return header("Proxy-Authorization", value); + } + + /** + * Sets the value for the <code>Range</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Range"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder range(Object value) { + return header("Range", value); + } + + /** + * Sets the value for the <code>Referer</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Referer"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder referer(Object value) { + return header("Referer", value); + } + + /** + * Sets the value for the <code>TE</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"TE"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder te(Object value) { + return header("TE", value); + } + + /** + * Sets the value for the <code>User-Agent</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"User-Agent"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder userAgent(Object value) { + return header("User-Agent", value); + } + + /** + * Sets the value for the <code>Upgrade</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Upgrade"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder upgrade(Object value) { + return header("Upgrade", value); + } + + /** + * Sets the value for the <code>Via</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Via"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder via(Object value) { + return header("Via", value); + } + + /** + * Sets the value for the <code>Warning</code> request header. + * <p> + * This is a shortcut for calling <code>header(<js>"Warning"</js>, value);</code> + * + * @param value The new header value. + * @return This object (for method chaining). + */ + public RestClientBuilder warning(Object value) { + return header("Warning", value); + } + + + //-------------------------------------------------------------------------------- + // CoreObject properties + //-------------------------------------------------------------------------------- + + /** + * Sets the {@link SerializerContext#SERIALIZER_maxDepth} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_maxDepth + */ + public RestClientBuilder maxDepth(int value) { + return property(SERIALIZER_maxDepth, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_initialDepth} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_initialDepth + */ + public RestClientBuilder initialDepth(int value) { + return property(SERIALIZER_initialDepth, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_detectRecursions} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_detectRecursions + */ + public RestClientBuilder detectRecursions(boolean value) { + return property(SERIALIZER_detectRecursions, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_ignoreRecursions} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_ignoreRecursions + */ + public RestClientBuilder ignoreRecursions(boolean value) { + return property(SERIALIZER_ignoreRecursions, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_useWhitespace} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_useWhitespace + */ + public RestClientBuilder useWhitespace(boolean value) { + return property(SERIALIZER_useWhitespace, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_addBeanTypeProperties} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_addBeanTypeProperties + */ + public RestClientBuilder addBeanTypeProperties(boolean value) { + return property(SERIALIZER_addBeanTypeProperties, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_quoteChar} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_quoteChar + */ + public RestClientBuilder quoteChar(char value) { + return property(SERIALIZER_quoteChar, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_trimNullProperties} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_trimNullProperties + */ + public RestClientBuilder trimNullProperties(boolean value) { + return property(SERIALIZER_trimNullProperties, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_trimEmptyCollections} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_trimEmptyCollections + */ + public RestClientBuilder trimEmptyCollections(boolean value) { + return property(SERIALIZER_trimEmptyCollections, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_trimEmptyMaps} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_trimEmptyMaps + */ + public RestClientBuilder trimEmptyMaps(boolean value) { + return property(SERIALIZER_trimEmptyMaps, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_trimStrings} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_trimStrings + */ + public RestClientBuilder trimStringsS(boolean value) { + return property(SERIALIZER_trimStrings, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_relativeUriBase} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_relativeUriBase + */ + public RestClientBuilder relativeUriBase(String value) { + return property(SERIALIZER_relativeUriBase, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_absolutePathUriBase} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_absolutePathUriBase + */ + public RestClientBuilder absolutePathUriBase(String value) { + return property(SERIALIZER_absolutePathUriBase, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_sortCollections} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_sortCollections + */ + public RestClientBuilder sortCollections(boolean value) { + return property(SERIALIZER_sortCollections, value); + } + + /** + * Sets the {@link SerializerContext#SERIALIZER_sortMaps} property on all serializers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see SerializerContext#SERIALIZER_sortMaps + */ + public RestClientBuilder sortMaps(boolean value) { + return property(SERIALIZER_sortMaps, value); + } + + /** + * Sets the {@link ParserContext#PARSER_trimStrings} property on all parsers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see ParserContext#PARSER_trimStrings + */ + public RestClientBuilder trimStringsP(boolean value) { + return property(PARSER_trimStrings, value); + } + + /** + * Sets the {@link ParserContext#PARSER_strict} property on all parsers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see ParserContext#PARSER_strict + */ + public RestClientBuilder strict(boolean value) { + return property(PARSER_strict, value); + } + + /** + * Sets the {@link ParserContext#PARSER_inputStreamCharset} property on all parsers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see ParserContext#PARSER_inputStreamCharset + */ + public RestClientBuilder inputStreamCharset(String value) { + return property(PARSER_inputStreamCharset, value); + } + + /** + * Sets the {@link ParserContext#PARSER_fileCharset} property on all parsers in this group. + * + * @param value The new value for this property. + * @return This object (for method chaining). + * @see ParserContext#PARSER_fileCharset + */ + public RestClientBuilder fileCharset(String value) { + return property(PARSER_fileCharset, value); + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beansRequireDefaultConstructor(boolean value) { + super.beansRequireDefaultConstructor(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beansRequireSerializable(boolean value) { + super.beansRequireSerializable(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beansRequireSettersForGetters(boolean value) { + super.beansRequireSettersForGetters(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beansRequireSomeProperties(boolean value) { + super.beansRequireSomeProperties(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanMapPutReturnsOldValue(boolean value) { + super.beanMapPutReturnsOldValue(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanConstructorVisibility(Visibility value) { + super.beanConstructorVisibility(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanClassVisibility(Visibility value) { + super.beanClassVisibility(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanFieldVisibility(Visibility value) { + super.beanFieldVisibility(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder methodVisibility(Visibility value) { + super.methodVisibility(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder useJavaBeanIntrospector(boolean value) { + super.useJavaBeanIntrospector(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder useInterfaceProxies(boolean value) { + super.useInterfaceProxies(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder ignoreUnknownBeanProperties(boolean value) { + super.ignoreUnknownBeanProperties(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder ignoreUnknownNullBeanProperties(boolean value) { + super.ignoreUnknownNullBeanProperties(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder ignorePropertiesWithoutSetters(boolean value) { + super.ignorePropertiesWithoutSetters(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder ignoreInvocationExceptionsOnGetters(boolean value) { + super.ignoreInvocationExceptionsOnGetters(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder ignoreInvocationExceptionsOnSetters(boolean value) { + super.ignoreInvocationExceptionsOnSetters(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder sortProperties(boolean value) { + super.sortProperties(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder notBeanPackages(String...values) { + super.notBeanPackages(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder notBeanPackages(Collection<String> values) { + super.notBeanPackages(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setNotBeanPackages(String...values) { + super.setNotBeanPackages(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setNotBeanPackages(Collection<String> values) { + super.setNotBeanPackages(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeNotBeanPackages(String...values) { + super.removeNotBeanPackages(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeNotBeanPackages(Collection<String> values) { + super.removeNotBeanPackages(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder notBeanClasses(Class<?>...values) { + super.notBeanClasses(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder notBeanClasses(Collection<Class<?>> values) { + super.notBeanClasses(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setNotBeanClasses(Class<?>...values) { + super.setNotBeanClasses(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setNotBeanClasses(Collection<Class<?>> values) { + super.setNotBeanClasses(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeNotBeanClasses(Class<?>...values) { + super.removeNotBeanClasses(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeNotBeanClasses(Collection<Class<?>> values) { + super.removeNotBeanClasses(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanFilters(Class<?>...values) { + super.beanFilters(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanFilters(Collection<Class<?>> values) { + super.beanFilters(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setBeanFilters(Class<?>...values) { + super.setBeanFilters(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setBeanFilters(Collection<Class<?>> values) { + super.setBeanFilters(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeBeanFilters(Class<?>...values) { + super.removeBeanFilters(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeBeanFilters(Collection<Class<?>> values) { + super.removeBeanFilters(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder pojoSwaps(Class<?>...values) { + super.pojoSwaps(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder pojoSwaps(Collection<Class<?>> values) { + super.pojoSwaps(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setPojoSwaps(Class<?>...values) { + super.setPojoSwaps(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setPojoSwaps(Collection<Class<?>> values) { + super.setPojoSwaps(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removePojoSwaps(Class<?>...values) { + super.removePojoSwaps(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removePojoSwaps(Collection<Class<?>> values) { + super.removePojoSwaps(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder implClasses(Map<Class<?>,Class<?>> values) { + super.implClasses(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public <T> RestClientBuilder implClass(Class<T> interfaceClass, Class<? extends T> implClass) { + super.implClass(interfaceClass, implClass); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanDictionary(Class<?>...values) { + super.beanDictionary(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanDictionary(Collection<Class<?>> values) { + super.beanDictionary(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setBeanDictionary(Class<?>...values) { + super.setBeanDictionary(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder setBeanDictionary(Collection<Class<?>> values) { + super.setBeanDictionary(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeFromBeanDictionary(Class<?>...values) { + super.removeFromBeanDictionary(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeFromBeanDictionary(Collection<Class<?>> values) { + super.removeFromBeanDictionary(values); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder beanTypePropertyName(String value) { + super.beanTypePropertyName(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder defaultParser(Class<?> value) { + super.defaultParser(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder locale(Locale value) { + super.locale(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder timeZone(TimeZone value) { + super.timeZone(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder mediaType(MediaType value) { + super.mediaType(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder debug(boolean value) { + super.debug(value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder property(String name, Object value) { + super.property(name, value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder properties(Map<String,Object> properties) { + super.properties(properties); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder addToProperty(String name, Object value) { + super.addToProperty(name, value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder putToProperty(String name, Object key, Object value) { + super.putToProperty(name, key, value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder putToProperty(String name, Object value) { + super.putToProperty(name, value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder removeFromProperty(String name, Object value) { + super.removeFromProperty(name, value); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder classLoader(ClassLoader classLoader) { + super.classLoader(classLoader); + return this; + } + + @Override /* CoreObjectBuilder */ + public RestClientBuilder apply(PropertyStore copyFrom) { + super.apply(copyFrom); + return this; + } + + + //------------------------------------------------------------------------------------------------ + // Passthrough methods for HttpClientBuilder. + //------------------------------------------------------------------------------------------------ + + /** + * @param redirectStrategy + * @return This object (for method chaining). + * @see HttpClientBuilder#setRedirectStrategy(RedirectStrategy) + */ + public RestClientBuilder setRedirectStrategy(RedirectStrategy redirectStrategy) { + httpClientBuilder.setRedirectStrategy(redirectStrategy); + return this; + } + + /** + * @param cookieSpecRegistry + * @return This object (for method chaining). + * @see HttpClientBuilder#setDefaultCookieSpecRegistry(Lookup) + */ + public RestClientBuilder setDefaultCookieSpecRegistry(Lookup<CookieSpecProvider> cookieSpecRegistry) { + httpClientBuilder.setDefaultCookieSpecRegistry(cookieSpecRegistry); + return this; + } + + /** + * @param requestExec + * @return This object (for method chaining). + * @see HttpClientBuilder#setRequestExecutor(HttpRequestExecutor) + */ + public RestClientBuilder setRequestExecutor(HttpRequestExecutor requestExec) { + httpClientBuilder.setRequestExecutor(requestExec); + return this; + } + + /** + * @param hostnameVerifier + * @return This object (for method chaining). + * @see HttpClientBuilder#setSSLHostnameVerifier(HostnameVerifier) + */ + public RestClientBuilder setSSLHostnameVerifier(HostnameVerifier hostnameVerifier) { + httpClientBuilder.setSSLHostnameVerifier(hostnameVerifier); + return this; + } + + /** + * @param publicSuffixMatcher + * @return This object (for method chaining). + * @see HttpClientBuilder#setPublicSuffixMatcher(PublicSuffixMatcher) + */ + public RestClientBuilder setPublicSuffixMatcher(PublicSuffixMatcher publicSuffixMatcher) { + httpClientBuilder.setPublicSuffixMatcher(publicSuffixMatcher); + return this; + } + + /** + * @param sslContext + * @return This object (for method chaining). + * @see HttpClientBuilder#setSSLContext(SSLContext) + */ + public RestClientBuilder setSSLContext(SSLContext sslContext) { + httpClientBuilder.setSSLContext(sslContext); + return this; + } + + /** + * @param sslSocketFactory + * @return This object (for method chaining). + * @see HttpClientBuilder#setSSLSocketFactory(LayeredConnectionSocketFactory) + */ + public RestClientBuilder setSSLSocketFactory(LayeredConnectionSocketFactory sslSocketFactory) { + httpClientBuilder.setSSLSocketFactory(sslSocketFactory); + return this; + } + + /** + * @param maxConnTotal + * @return This object (for method chaining). + * @see HttpClientBuilder#setMaxConnTotal(int) + */ + public RestClientBuilder setMaxConnTotal(int maxConnTotal) { + httpClientBuilder.setMaxConnTotal(maxConnTotal); + return this; + } + + /** + * @param maxConnPerRoute + * @return This object (for method chaining). + * @see HttpClientBuilder#setMaxConnPerRoute(int) + */ + public RestClientBuilder setMaxConnPerRoute(int maxConnPerRoute) { + httpClientBuilder.setMaxConnPerRoute(maxConnPerRoute); + return this; + } + + /** + * @param config + * @return This object (for method chaining). + * @see HttpClientBuilder#setDefaultSocketConfig(SocketConfig) + */ + public RestClientBuilder setDefaultSocketConfig(SocketConfig config) { + httpClientBuilder.setDefaultSocketConfig(config); + return this; + } + + /** + * @param config + * @return This object (for method chaining). + * @see HttpClientBuilder#setDefaultConnectionConfig(ConnectionConfig) + */ + public RestClientBuilder setDefaultConnectionConfig(ConnectionConfig config) { + httpClientBuilder.setDefaultConnectionConfig(config); + return this; + } + + /** + * @param connTimeToLive + * @param connTimeToLiveTimeUnit + * @return This object (for method chaining). + * @see HttpClientBuilder#setConnectionTimeToLive(long,TimeUnit) + */ + public RestClientBuilder setConnectionTimeToLive(long connTimeToLive, TimeUnit connTimeToLiveTimeUnit) { + httpClientBuilder.setConnectionTimeToLive(connTimeToLive, connTimeToLiveTimeUnit); + return this; + } + + /** + * @param connManager + * @return This object (for method chaining). + * @see HttpClientBuilder#setConnectionManager(HttpClientConnectionManager) + */ + public RestClientBuilder setConnectionManager(HttpClientConnectionManager connManager) { + this.httpClientConnectionManager = connManager; + httpClientBuilder.setConnectionManager(connManager); + return this; + } + + /** + * @param shared + * @return This object (for method chaining). + * @see HttpClientBuilder#setConnectionManagerShared(boolean) + */ + public RestClientBuilder setConnectionManagerShared(boolean shared) { + httpClientBuilder.setConnectionManagerShared(shared); + return this; + } + + /** + * @param reuseStrategy + * @return This object (for method chaining). + * @see HttpClientBuilder#setConnectionReuseStrategy(ConnectionReuseStrategy) + */ + public RestClientBuilder setConnectionReuseStrategy(ConnectionReuseStrategy reuseStrategy) { + httpClientBuilder.setConnectionReuseStrategy(reuseStrategy); + return this; + } + + /** + * @param keepAliveStrategy + * @return This object (for method chaining). + * @see HttpClientBuilder#setKeepAliveStrategy(ConnectionKeepAliveStrategy) + */ + public RestClientBuilder setKeepAliveStrategy(ConnectionKeepAliveStrategy keepAliveStrategy) { + httpClientBuilder.setKeepAliveStrategy(keepAliveStrategy); + return this; + } + + /** + * @param targetAuthStrategy + * @return This object (for method chaining). + * @see HttpClientBuilder#setTargetAuthenticationStrategy(AuthenticationStrategy) + */ + public RestClientBuilder setTargetAuthenticationStrategy(AuthenticationStrategy targetAuthStrategy) { + httpClientBuilder.setTargetAuthenticationStrategy(targetAuthStrategy); + return this; + } + + /** + * @param proxyAuthStrategy + * @return This object (for method chaining). + * @see HttpClientBuilder#setProxyAuthenticationStrategy(AuthenticationStrategy) + */ + public RestClientBuilder setProxyAuthenticationStrategy(AuthenticationStrategy proxyAuthStrategy) { + httpClientBuilder.setProxyAuthenticationStrategy(proxyAuthStrategy); + return this; + } + + /** + * @param userTokenHandler + * @return This object (for method chaining). + * @see HttpClientBuilder#setUserTokenHandler(UserTokenHandler) + */ + public RestClientBuilder setUserTokenHandler(UserTokenHandler userTokenHandler) { + httpClientBuilder.setUserTokenHandler(userTokenHandler); + return this; + } + + /** + * @return This object (for method chaining). + * @see HttpClientBuilder#disableConnectionState() + */ + public RestClientBuilder disableConnectionState() { + httpClientBuilder.disableConnectionState(); + return this; + } + + /** + * @param schemePortResolver + * @return This object (for method chaining). + * @see HttpClientBuilder#setSchemePortResolver(SchemePortResolver) + */ + public RestClientBuilder setSchemePortResolver(SchemePortResolver schemePortResolver) { + httpClientBuilder.setSchemePortResolver(schemePortResolver); + return this; + } + + /** + * @param userAgent + * @return This object (for method chaining). + * @see HttpClientBuilder#setUserAgent(String) + */ + public RestClientBuilder setUserAgent(String userAgent) { + httpClientBuilder.setUserAgent(userAgent); + return this; + } + + /** + * @param defaultHeaders + * @return This object (for method chaining). + * @see HttpClientBuilder#setDefaultHeaders(Collection) + */ + public RestClientBuilder setDefaultHeaders(Collection<? extends Header> defaultHeaders) { + httpClientBuilder.setDefaultHeaders(defaultHeaders); + return this; + } + + /** + * @param itcp + * @return This object (for method chaining). + * @see HttpClientBuilder#addInterceptorFirst(HttpResponseInterceptor) + */ + public RestClientBuilder addInterceptorFirst(HttpResponseInterceptor itcp) { + httpClientBuilder.addInterceptorFirst(itcp); + return this; + } + + /** + * @param itcp + * @return This object (for method chaining). + * @see HttpClientBuilder#addInterceptorLast(HttpResponseInterceptor) + */ + public RestClientBuilder addInterceptorLast(HttpResponseInterceptor itcp) { + httpClientBuilder.addInterceptorLast(itcp); + return this; + } + + /** + * @param itcp + * @return This object (for method chaining). + * @see HttpClientBuilder#addInterceptorFirst(HttpRequestInterceptor) + */ + public RestClientBuilder addInterceptorFirst(HttpRequestInterceptor itcp) { + httpClientBuilder.addInterceptorFirst(itcp); + return this; + } + + /** + * @param itcp + * @return This object (for method chaining). + * @see HttpClientBuilder#addInterceptorLast(HttpRequestInterceptor) + */ + public RestClientBuilder addInterceptorLast(HttpRequestInterceptor itcp) { + httpClientBuilder.addInterceptorLast(itcp); + return this; + } + + /** + * @return This object (for method chaining). + * @see HttpClientBuilder#disableCookieManagement() + */ + public RestClientBuilder disableCookieManagement() { + httpClientBuilder.disableCookieManagement(); + return this; + } + + /** + * @return This object (for method chaining). + * @see HttpClientBuilder#disableContentCompression() + */ + public RestClientBuilder disableContentCompression() { + httpClientBuilder.disableContentCompression(); + return this; + } + + /** + * @return This object (for method chaining). + * @see HttpClientBuilder#disableAuthCaching() + */ + public RestClientBuilder disableAuthCaching() { + httpClientBuilder.disableAuthCaching(); + return this; + } + + /** + * @param httpprocessor + * @return This object (for method chaining). + * @see HttpClientBuilder#setHttpProcessor(HttpProcessor) + */ + public RestClientBuilder setHttpProcessor(HttpProcessor httpprocessor) { + httpClientBuilder.setHttpProcessor(httpprocessor); + return this; + } + + /** + * @param retryHandler + * @return This object (for method chaining). + * @see HttpClientBuilder#setRetryHandler(HttpRequestRetryHandler) + */ + public RestClientBuilder setRetryHandler(HttpRequestRetryHandler retryHandler) { + httpClientBuilder.setRetryHandler(retryHandler); + return this; + } + + /** + * @return This object (for method chaining). + * @see HttpClientBuilder#disableAutomaticRetries() + */ + public RestClientBuilder disableAutomaticRetries() { + httpClientBuilder.disableAutomaticRetries(); + return this; + } + + /** + * @param proxy + * @return This object (for method chaining). + * @see HttpClientBuilder#setProxy(HttpHost) + */ + public RestClientBuilder setProxy(HttpHost proxy) { + httpClientBuilder.setProxy(proxy); + return this; + } + + /** + * @param routePlanner + * @return This object (for method chaining). + * @see HttpClientBuilder#setRoutePlanner(HttpRoutePlanner) + */ + public RestClientBuilder setRoutePlanner(HttpRoutePlanner routePlanner) { + httpClientBuilder.setRoutePlanner(routePlanner); + return this; + } + + /** + * @return This object (for method chaining). + * @see HttpClientBuilder#disableRedirectHandling() + */ + public RestClientBuilder disableRedirectHandling() { + httpClientBuilder.disableRedirectHandling(); + return this; + } + + /** + * @param connectionBackoffStrategy + * @return This object (for method chaining). + * @see HttpClientBuilder#setConnectionBackoffStrategy(ConnectionBackoffStrategy) + */ + public RestClientBuilder setConnectionBackoffStrategy(ConnectionBackoffStrategy connectionBackoffStrategy) { + httpClientBuilder.setConnectionBackoffStrategy(connectionBackoffStrategy); + return this; + } + + /** + * @param backoffManager + * @return This object (for method chaining). + * @see HttpClientBuilder#setBackoffManager(BackoffManager) + */ + public RestClientBuilder setBackoffManager(BackoffManager backoffManager) { + httpClientBuilder.setBackoffManager(backoffManager); + return this; + } + + /** + * @param serviceUnavailStrategy + * @return This object (for method chaining). + * @see HttpClientBuilder#setServiceUnavailableRetryStrategy(ServiceUnavailableRetryStrategy) + */ + public RestClientBuilder setServiceUnavailableRetryStrategy(ServiceUnavailableRetryStrategy serviceUnavailStrategy) { + httpClientBuilder.setServiceUnavailableRetryStrategy(serviceUnavailStrategy); + return this; + } + + /** + * @param cookieStore + * @return This object (for method chaining). + * @see HttpClientBuilder#setDefaultCookieStore(CookieStore) + */ + public RestClientBuilder setDefaultCookieStore(CookieStore cookieStore) { + httpClientBuilder.setDefaultCookieStore(cookieStore); + return this; + } + + /** + * @param credentialsProvider + * @return This object (for method chaining). + * @see HttpClientBuilder#setDefaultCredentialsProvider(CredentialsProvider) + */ + public RestClientBuilder setDefaultCredentialsProvider(CredentialsProvider credentialsProvider) { + httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider); + return this; + } + + /** + * @param authSchemeRegistry + * @return This object (for method chaining). + * @see HttpClientBuilder#setDefaultAuthSchemeRegistry(Lookup) + */ + public RestClientBuilder setDefaultAuthSchemeRegistry(Lookup<AuthSchemeProvider> authSchemeRegistry) { + httpClientBuilder.setDefaultAuthSchemeRegistry(authSchemeRegistry); + return this; + } + + /** + * @param contentDecoderMap + * @return This object (for method chaining). + * @see HttpClientBuilder#setContentDecoderRegistry(Map) + */ + public RestClientBuilder setContentDecoderRegistry(Map<String,InputStreamFactory> contentDecoderMap) { + httpClientBuilder.setContentDecoderRegistry(contentDecoderMap); + return this; + } + + /** + * @param config + * @return This object (for method chaining). + * @see HttpClientBuilder#setDefaultRequestConfig(RequestConfig) + */ + public RestClientBuilder setDefaultRequestConfig(RequestConfig config) { + httpClientBuilder.setDefaultRequestConfig(config); + return this; + } + + /** + * @return This object (for method chaining). + * @see HttpClientBuilder#useSystemProperties() + */ + public RestClientBuilder useSystemProperties() { + httpClientBuilder.useSystemProperties(); + return this; + } + + /** + * @return This object (for method chaining). + * @see HttpClientBuilder#evictExpiredConnections() + */ + public RestClientBuilder evictExpiredConnections() { + httpClientBuilder.evictExpiredConnections(); + return this; + } + + /** + * @param maxIdleTime + * @param maxIdleTimeUnit + * @return This object (for method chaining). + * @see HttpClientBuilder#evictIdleConnections(long,TimeUnit) + */ + public RestClientBuilder evictIdleConnections(long maxIdleTime, TimeUnit maxIdleTimeUnit) { + httpClientBuilder.evictIdleConnections(maxIdleTime, maxIdleTimeUnit); + return this; + } +}
http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RetryOn.java ---------------------------------------------------------------------- diff --git a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RetryOn.java b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RetryOn.java index 34024c7..6a1c542 100644 --- a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RetryOn.java +++ b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RetryOn.java @@ -28,6 +28,16 @@ public interface RetryOn { }; /** + * Default RetryOn that returns <jk>true</jk> if the HTTP connection could not be made. + */ + public static final RetryOn CONNECTION_LOST = new RetryOn() { + @Override /* RetryOn */ + public boolean onCode(int httpResponseCode) { + return httpResponseCode <= 0; + } + }; + + /** * Subclasses should override this method to determine whether the HTTP response is retryable. * * @param httpResponseCode The HTTP response code. http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SSLOpts.java ---------------------------------------------------------------------- diff --git a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SSLOpts.java b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SSLOpts.java index 52f5766..e0041da 100644 --- a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SSLOpts.java +++ b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SSLOpts.java @@ -15,7 +15,7 @@ package org.apache.juneau.rest.client; import org.apache.juneau.internal.*; /** - * SSL configuration options that get passed to {@link RestClient#enableSSL(SSLOpts)}. + * SSL configuration options that get passed to {@link RestClientBuilder#enableSSL(SSLOpts)}. */ public class SSLOpts { http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SerializedNameValuePair.java ---------------------------------------------------------------------- diff --git a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SerializedNameValuePair.java b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SerializedNameValuePair.java index 17a7dde..f90c393 100644 --- a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SerializedNameValuePair.java +++ b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/SerializedNameValuePair.java @@ -12,12 +12,13 @@ // *************************************************************************************************************************** package org.apache.juneau.rest.client; -import static org.apache.juneau.urlencoding.UonSerializerContext.*; +import static org.apache.juneau.uon.UonSerializerContext.*; import java.io.*; import org.apache.http.*; import org.apache.juneau.*; +import org.apache.juneau.uon.*; import org.apache.juneau.urlencoding.*; /** http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/package.html ---------------------------------------------------------------------- diff --git a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/package.html b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/package.html index 55797bb..8e30aaa 100644 --- a/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/package.html +++ b/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/package.html @@ -115,7 +115,7 @@ <jc>// Examples below use the Juneau Address Book resource example</jc> <jc>// Create a reusable client with JSON support</jc> - RestClient client = <jk>new</jk> RestClient(JsonSerializer.<jk>class</jk>, JsonParser.<jk>class</jk>); + RestClient client = <jk>new</jk> RestClientBuilder().build(); <jc>// GET request, ignoring output</jc> <jk>try</jk> { @@ -185,7 +185,7 @@ .getResponse(Boolean.<jk>class</jk>); <jc>// GET request, getting a filtered object</jc> - client.getParser().addPojoSwaps(CalendarSwap.<jsf>ISO8601</jsf>.<jk>class</jk>); + client = <jk>new</jk> RestClientBuilder().pojoSwaps(CalendarSwap.<jsf>ISO8601</jsf>.<jk>class</jk>).build(); Calendar birthDate = client.doGet(<js>"http://localhost:9080/sample/addressBook/0/birthDate";</js>) .getResponse(GregorianCalendar.<jk>class</jk>); @@ -213,7 +213,7 @@ <h3 class='topic' onclick='toggle(this)'>1.1 - SSL Support</h3> <div class='topic'> <p> - The simplest way to enable SSL support in the client is to use the {@link org.apache.juneau.rest.client.RestClient#enableSSL(SSLOpts)} method + The simplest way to enable SSL support in the client is to use the {@link org.apache.juneau.rest.client.RestClientBuilder#enableSSL(SSLOpts)} method and one of the predefined {@link org.apache.juneau.rest.client.SSLOpts} instances: </p> <ul> @@ -223,18 +223,18 @@ <h6 class='topic'>Example:</h6> <p class='bcode'> <jc>// Create a client that ignores self-signed or otherwise invalid certificates.</jc> - RestClient restClient = <jk>new</jk> RestClient() + RestClientBuilder builder = <jk>new</jk> RestClientBuilder() .enableSSL(SSLOpts.<jsf>LAX</jsf>); <jc>// ...or...</jc> - RestClient restClient = <jk>new</jk> RestClient() + RestClientBuilder builder = <jk>new</jk> RestClientBuilder() .enableLaxSSL(); </p> <p> This is functionally equivalent to the following: </p> <p class='bcode'> - RestClient restClient = <jk>new</jk> RestClient(); + RestClientBuilder builder = <jk>new</jk> RestClientBuilder(); HostnameVerifier hv = <jk>new</jk> NoopHostnameVerifier(); TrustManager tm = <jk>new</jk> SimpleX509TrustManager(<jk>true</jk>); @@ -243,9 +243,9 @@ SSLContext ctx = SSLContext.<jsm>getInstance</jsm>(p); ctx.init(<jk>null</jk>, <jk>new</jk> TrustManager[] { tm }, <jk>null</jk>); SSLConnectionSocketFactory sf = <jk>new</jk> SSLConnectionSocketFactory(ctx, hv); - restClient.setSSLSocketFactory(sf); + builder.setSSLSocketFactory(sf); Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory><jsm>.create</jsm>().register(<js>"https"</js>, sf).build(); - restClient.setConnectionManager(<jk>new</jk> PoolingHttpClientConnectionManager(r)); + builder.setConnectionManager(<jk>new</jk> PoolingHttpClientConnectionManager(r)); } </p> <p> @@ -289,25 +289,26 @@ <h4 class='topic' onclick='toggle(this)'>1.2.1 - BASIC Authentication</h4> <div class='topic'> <p> - The {@link org.apache.juneau.rest.client.RestClient#setBasicAuth(String,int,String,String)} method can be used to quickly enable + The {@link org.apache.juneau.rest.client.RestClientBuilder#basicAuth(String,int,String,String)} method can be used to quickly enable BASIC authentication support. </p> <h6 class='topic'>Example:</h6> <p class='bcode'> <jc>// Create a client that performs BASIC authentication using the specified user/pw.</jc> - RestClient restClient = <jk>new</jk> RestClient() - .setBasicAuth(<jsf>HOST</jsf>, <jsf>PORT</jsf>, <jsf>USER</jsf>, <jsf>PW</jsf>); + RestClient restClient = <jk>new</jk> RestClientBuilder() + .setBasicAuth(<jsf>HOST</jsf>, <jsf>PORT</jsf>, <jsf>USER</jsf>, <jsf>PW</jsf>) + .build(); </p> <p> This is functionally equivalent to the following: </p> <p class='bcode'> - RestClient restClient = <jk>new</jk> RestClient(); + RestClientBuilder builder = <jk>new</jk> RestClientBuilder(); AuthScope scope = <jk>new</jk> AuthScope(<jsf>HOST</jsf>, <jsf>PORT</jsf>); Credentials up = <jk>new</jk> UsernamePasswordCredentials(<jsf>USER</jsf>, <jsf>PW</jsf>); CredentialsProvider p = <jk>new</jk> BasicCredentialsProvider(); p.setCredentials(scope, up); - restClient.setDefaultCredentialsProvider(p); + builder.setDefaultCredentialsProvider(p); </p> </div> @@ -316,10 +317,10 @@ <h4 class='topic' onclick='toggle(this)'>1.2.2 - FORM-based Authentication</h4> <div class='topic'> <p> - The {@link org.apache.juneau.rest.client.RestClient} class does not itself provide FORM-based authentication since there + The {@link org.apache.juneau.rest.client.RestClientBuilder} class does not itself provide FORM-based authentication since there is no standard way of providing such support. Typically, to perform FORM-based or other types of authentication, you'll want to create your own - subclass of {@link org.apache.juneau.rest.client.RestClient} and override the {@link org.apache.juneau.rest.client.RestClient#createHttpClient()} + subclass of {@link org.apache.juneau.rest.client.RestClientBuilder} and override the {@link org.apache.juneau.rest.client.RestClientBuilder#createHttpClient()} method to provide an authenticated client. </p> <p> @@ -330,14 +331,14 @@ <jd>/** * Constructor. */</jd> - <jk>public</jk> JazzRestClient(URI jazzUri, String user, String pw) <jk>throws</jk> IOException { + <jk>public</jk> JazzRestClientBuilder(URI jazzUri, String user, String pw) <jk>throws</jk> IOException { ... } <jd>/** * Override the createHttpClient() method to return an authenticated client. */</jd> - <ja>@Override</ja> <jc>/* RestClient */</jc> + <ja>@Override</ja> <jc>/* RestClientBuilder */</jc> <jk>protected</jk> CloseableHttpClient createHttpClient() <jk>throws</jk> Exception { CloseableHttpClient client = <jk>super</jk>.createHttpClient(); formBasedAuthenticate(client); @@ -411,14 +412,14 @@ <jd>/** * Constructor. */</jd> - <jk>public</jk> JazzRestClient(URI jazzUri, String user, String pw) <jk>throws</jk> IOException { + <jk>public</jk> JazzRestClientBuilder(URI jazzUri, String user, String pw) <jk>throws</jk> IOException { ... } <jd>/** * Override the createHttpClient() method to return an authenticated client. */</jd> - <ja>@Override</ja> <jc>/* RestClient */</jc> + <ja>@Override</ja> <jc>/* RestClientBuilder */</jc> <jk>protected</jk> CloseableHttpClient createHttpClient() <jk>throws</jk> Exception { CloseableHttpClient client = <jk>super</jk>.createHttpClient(); oidcAuthenticate(client); @@ -557,7 +558,7 @@ .run(); </p> <p> - These convenience methods are specialized methods that use the {@link org.apache.juneau.rest.client.RestCall#addResponsePattern(ResponsePattern)} + These convenience methods are specialized methods that use the {@link org.apache.juneau.rest.client.RestCall#responsePattern(ResponsePattern)} method which uses regular expression matching against the response body. This method can be used to search for arbitrary patterns in the response body. </p> @@ -631,7 +632,7 @@ <h3 class='topic' onclick='toggle(this)'>1.5 - Logging</h3> <div class='topic'> <p> - Use the {@link org.apache.juneau.rest.client.RestClient#logTo(Level,Logger)} and {@link org.apache.juneau.rest.client.RestCall#logTo(Level,Logger)} methods + Use the {@link org.apache.juneau.rest.client.RestClientBuilder#logTo(Level,Logger)} and {@link org.apache.juneau.rest.client.RestCall#logTo(Level,Logger)} methods to log HTTP calls. These methods will cause the HTTP request and response headers and body to be logged to the specified logger. </p> @@ -645,7 +646,7 @@ </p> <p> Customized logging can be handled by subclassing the {@link org.apache.juneau.rest.client.RestCallLogger} class and using the - {@link org.apache.juneau.rest.client.RestCall#addInterceptor(RestCallInterceptor)} method. + {@link org.apache.juneau.rest.client.RestCall#interceptor(RestCallInterceptor)} method. </p> </div> @@ -654,7 +655,7 @@ <h3 class='topic' onclick='toggle(this)'>1.6 - Interceptors</h3> <div class='topic'> <p> - The {@link org.apache.juneau.rest.client.RestClient#addInterceptor(RestCallInterceptor)} and {@link org.apache.juneau.rest.client.RestCall#addInterceptor(RestCallInterceptor)} methods + The {@link org.apache.juneau.rest.client.RestClientBuilder#interceptor(RestCallInterceptor)} and {@link org.apache.juneau.rest.client.RestCall#interceptor(RestCallInterceptor)} methods can be used to intercept responses during specific connection lifecycle events. </p> <p> @@ -763,7 +764,7 @@ </p> <p> Proxy interfaces are retrieved using the {@link org.apache.juneau.rest.client.RestClient#getRemoteableProxy(Class)} method. - The {@link org.apache.juneau.rest.client.RestClient#setRemoteableServletUri(String)} method is used to specify the location + The {@link org.apache.juneau.rest.client.RestClientBuilder#remoteableServletUri(String)} method is used to specify the location of the remoteable services servlet running on the server. The remoteable servlet is a specialized subclass of {@link org.apache.juneau.rest.RestServlet} that provides a full-blown REST interface for calling interfaces remotely. @@ -781,8 +782,9 @@ </p> <p class='bcode'> <jc>// Create a RestClient using JSON for serialization, and point to the server-side remoteable servlet.</jc> - RestClient client = <jk>new</jk> RestClient(JsonSerializer.<jk>class</jk>, JsonParser.<jk>class</jk>) - .setRemoteableServletUri(<js>"https://localhost:9080/juneau/sample/remoteable";</js>); + RestClient client = <jk>new</jk> RestClientBuilder() + .remoteableServletUri(<js>"https://localhost:9080/juneau/sample/remoteable";</js>) + .build(); <jc>// Create a proxy interface.</jc> IAddressBook ab = client.getRemoteableProxy(IAddressBook.<jk>class</jk>); @@ -818,28 +820,30 @@ <h3 class='topic' onclick='toggle(this)'>1.8 - Other Useful Methods</h3> <div class='topic'> <p> - The {@link org.apache.juneau.rest.client.RestClient#setRootUrl(Object)} method can be used to specify a root URL on + The {@link org.apache.juneau.rest.client.RestClientBuilder#rootUrl(Object)} method can be used to specify a root URL on all requests so that you don't have to use absolute paths on individual calls. </p> <p class='bcode'> <jc>// Create a rest client with a root URL</jc> - RestClient rc = <jk>new</jk> RestClient().setRootUrl(<js>"http://localhost:9080/foobar";</js>); + RestClient rc = <jk>new</jk> RestClientBuilder().rootUrl(<js>"http://localhost:9080/foobar";</js>).build(); String r = rc.doGet(<js>"/baz"</js>).getResponseAsString(); <jc>// Gets "http://localhost:9080/foobar/baz";</jc> </p> <p> - The {@link org.apache.juneau.rest.client.RestClient#setProperty(String,Object)} method can be used to set serializer + The {@link org.apache.juneau.rest.client.RestClientBuilder#property(String,Object)} method can be used to set serializer and parser properties. For example, if you're parsing a response into POJOs and you want to ignore fields that aren't on the POJOs, you can use the {@link org.apache.juneau.BeanContext#BEAN_ignoreUnknownBeanProperties} property. </p> <p class='bcode'> <jc>// Create a rest client that ignores unknown fields in the response</jc> - RestClient rc = <jk>new</jk> RestClient(JsonSerializer.<jk>class</jk>, JsonParser.<jk>class</jk>) - .setProperty(<jsf>BEAN_ignoreUnknownBeanProperties</jsf>, <jk>true</jk>); + RestClient rc = <jk>new</jk> RestClientBuilder() + .property(<jsf>BEAN_ignoreUnknownBeanProperties</jsf>, <jk>true</jk>) + <jc>// or .ignoreUnknownBeanProperties(true)</jc> + .build(); MyPojo myPojo = rc.doGet(<jsf>URL</jsf>).getResponse(MyPojo.<jk>class</jk>); </p> <p> - The {@link org.apache.juneau.rest.client.RestCall#setRetryable(int,long,RetryOn)} method can be used to automatically + The {@link org.apache.juneau.rest.client.RestCall#retryable(int,long,RetryOn)} method can be used to automatically retry requests on failures. This can be particularly useful if you're attempting to connect to a REST resource that may be in the process of still initializing. @@ -848,7 +852,7 @@ <jc>// Create a rest call that retries every 10 seconds for up to 30 minutes as long as a connection fails // or a 400+ is received.</jc> restClient.doGet(<jsf>URL</jsf>) - .setRetryable(180, 10000, RetryOn.<jsf>DEFAULT</jsf>) + .retryable(180, 10000, RetryOn.<jsf>DEFAULT</jsf>) .run(); </p> </div> http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/BaseProvider.java ---------------------------------------------------------------------- diff --git a/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/BaseProvider.java b/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/BaseProvider.java index 1a26708..4ee84be 100644 --- a/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/BaseProvider.java +++ b/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/BaseProvider.java @@ -35,8 +35,8 @@ import org.apache.juneau.serializer.*; */ public class BaseProvider implements MessageBodyReader<Object>, MessageBodyWriter<Object> { - private SerializerGroup serializers = new SerializerGroup(); - private ParserGroup parsers = new ParserGroup(); + private SerializerGroup serializers; + private ParserGroup parsers; private ObjectMap properties = new ObjectMap(); /** @@ -46,14 +46,24 @@ public class BaseProvider implements MessageBodyReader<Object>, MessageBodyWrite try { properties = new ObjectMap(); JuneauProvider jp = getClass().getAnnotation(JuneauProvider.class); - serializers.append(jp.serializers()); - parsers.append(jp.parsers()); + for (Property p : jp.properties()) properties.put(p.name(), p.value()); - serializers.addBeanFilters(jp.beanFilters()); - parsers.addBeanFilters(jp.beanFilters()); - serializers.addPojoSwaps(jp.pojoSwaps()); - parsers.addPojoSwaps(jp.pojoSwaps()); + + serializers = new SerializerGroupBuilder() + .append(jp.serializers()) + .beanFilters(jp.beanFilters()) + .pojoSwaps(jp.pojoSwaps()) + .properties(properties) + .build(); + + parsers = new ParserGroupBuilder() + .append(jp.parsers()) + .beanFilters(jp.beanFilters()) + .pojoSwaps(jp.pojoSwaps()) + .properties(properties) + .build(); + } catch (Exception e) { throw new RuntimeException(e); } http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/DefaultProvider.java ---------------------------------------------------------------------- diff --git a/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/DefaultProvider.java b/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/DefaultProvider.java index 92cc4a1..1407508 100644 --- a/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/DefaultProvider.java +++ b/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/DefaultProvider.java @@ -31,8 +31,8 @@ import org.apache.juneau.xml.*; "application/json", "text/json", // JsonSerializer "application/json+simple", "text/json+simple", // JsonSerializer.Simple "application/json+schema", // JsonSchemaSerializer - "text/xml", // XmlDocSerializer - "text/xml+simple", // XmlDocSerializer.Simple + "text/xml", // XmlDocSerializer.Ns + "text/xml+simple", // XmlDocSerializer "text/xml+schema", // XmlSchemaDocSerializer "text/html", // HtmlDocSerializer "application/x-www-form-urlencoded", // UrlEncodingSerializer @@ -51,20 +51,19 @@ import org.apache.juneau.xml.*; JsonSerializer.class, JsonSerializer.Simple.class, JsonSchemaSerializer.class, + XmlDocSerializer.Ns.class, XmlDocSerializer.class, - XmlDocSerializer.Simple.class, XmlSchemaDocSerializer.class, HtmlDocSerializer.class, UrlEncodingSerializer.class, SoapXmlSerializer.class, - JavaSerializedObjectSerializer.class + JsoSerializer.class }, parsers={ JsonParser.class, XmlParser.class, HtmlParser.class, UrlEncodingParser.class, - JavaSerializedObjectParser.class } ) public final class DefaultProvider extends BaseProvider {} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/rdf/DefaultJenaProvider.java ---------------------------------------------------------------------- diff --git a/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/rdf/DefaultJenaProvider.java b/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/rdf/DefaultJenaProvider.java index e4208c9..5c60247 100644 --- a/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/rdf/DefaultJenaProvider.java +++ b/juneau-rest-jaxrs/src/main/java/org/apache/juneau/rest/jaxrs/rdf/DefaultJenaProvider.java @@ -33,8 +33,8 @@ import org.apache.juneau.xml.*; "application/json", "text/json", // JsonSerializer "application/json+simple","text/json+simple", // JsonSerializer.Simple "application/json+schema","text/json+schema", // JsonSchemaSerializer - "text/xml", // XmlDocSerializer - "text/xml+simple", // XmlDocSerializer.Simple + "text/xml", // XmlDocSerializer.Ns + "text/xml+simple", // XmlDocSerializer "text/xml+schema", // XmlSchemaDocSerializer "text/html", // HtmlDocSerializer "application/x-www-form-urlencoded", // UrlEncodingSerializer @@ -62,8 +62,7 @@ import org.apache.juneau.xml.*; JsonSerializer.class, JsonSerializer.Simple.class, JsonSchemaSerializer.class, - XmlDocSerializer.class, - XmlDocSerializer.Simple.class, + XmlDocSerializer.Ns.class, XmlSchemaDocSerializer.class, HtmlDocSerializer.class, UrlEncodingSerializer.class, @@ -73,7 +72,7 @@ import org.apache.juneau.xml.*; RdfSerializer.NTriple.class, RdfSerializer.Turtle.class, RdfSerializer.N3.class, - JavaSerializedObjectSerializer.class + JsoSerializer.class }, parsers={ JsonParser.class, @@ -83,8 +82,7 @@ import org.apache.juneau.xml.*; RdfParser.Xml.class, RdfParser.NTriple.class, RdfParser.Turtle.class, - RdfParser.N3.class, - JavaSerializedObjectParser.class, + RdfParser.N3.class } ) public final class DefaultJenaProvider extends BaseProvider {} http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/AcceptCharsetResource.java ---------------------------------------------------------------------- diff --git a/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/AcceptCharsetResource.java b/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/AcceptCharsetResource.java index f1d04fa..ee3a172 100644 --- a/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/AcceptCharsetResource.java +++ b/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/AcceptCharsetResource.java @@ -56,6 +56,11 @@ public class AcceptCharsetResource extends RestServlet { @Consumes("text/plain") public static class TestParser extends InputStreamParser { + + public TestParser(PropertyStore propertyStore) { + super(propertyStore); + } + @SuppressWarnings("unchecked") @Override /* Parser */ protected <T> T doParse(ParserSession session, ClassMeta<T> type) throws Exception { @@ -65,6 +70,11 @@ public class AcceptCharsetResource extends RestServlet { @Produces("text/plain") public static class TestSerializer extends OutputStreamSerializer { + + public TestSerializer(PropertyStore propertyStore) { + super(propertyStore); + } + @Override /* Serializer */ protected void doSerialize(SerializerSession session, Object o) throws Exception { Writer w = new OutputStreamWriter(session.getOutputStream()); http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/CharsetEncodingsResource.java ---------------------------------------------------------------------- diff --git a/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/CharsetEncodingsResource.java b/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/CharsetEncodingsResource.java index 539f88d..4f9e6f3 100644 --- a/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/CharsetEncodingsResource.java +++ b/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/CharsetEncodingsResource.java @@ -33,6 +33,11 @@ public class CharsetEncodingsResource extends RestServlet { @Consumes("text/p") public static class CtParser extends ReaderParser { + + public CtParser(PropertyStore propertyStore) { + super(propertyStore); + } + @SuppressWarnings("unchecked") @Override /* Parser */ protected <T> T doParse(ParserSession session, ClassMeta<T> type) throws Exception { @@ -42,6 +47,11 @@ public class CharsetEncodingsResource extends RestServlet { @Produces("text/s") public static class ASerializer extends WriterSerializer { + + public ASerializer(PropertyStore propertyStore) { + super(propertyStore); + } + @Override /* Serializer */ protected void doSerialize(SerializerSession session, Object o) throws Exception { session.getWriter().write(o.toString()); http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/95e832e1/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/DefaultContentTypesResource.java ---------------------------------------------------------------------- diff --git a/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/DefaultContentTypesResource.java b/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/DefaultContentTypesResource.java index 01dd128..73544e7 100644 --- a/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/DefaultContentTypesResource.java +++ b/juneau-rest-test/src/main/java/org/apache/juneau/rest/test/DefaultContentTypesResource.java @@ -34,22 +34,22 @@ public class DefaultContentTypesResource extends RestServlet { private static final long serialVersionUID = 1L; @Consumes("text/p1") - public static class P1 extends DummyParser { public P1() {super("p1");}} + public static class P1 extends DummyParser { public P1(PropertyStore ps) {super(ps, "p1");}} @Consumes("text/p2") - public static class P2 extends DummyParser { public P2() {super("p2");}} + public static class P2 extends DummyParser { public P2(PropertyStore ps) {super(ps, "p2");}} @Consumes("text/p3") - public static class P3 extends DummyParser { public P3() {super("p3");}} + public static class P3 extends DummyParser { public P3(PropertyStore ps) {super(ps, "p3");}} @Produces("text/s1") - public static class S1 extends DummySerializer { public S1() {super("s1");}} + public static class S1 extends DummySerializer { public S1(PropertyStore ps) {super(ps, "s1");}} @Produces("text/s2") - public static class S2 extends DummySerializer { public S2() {super("s2");}} + public static class S2 extends DummySerializer { public S2(PropertyStore ps) {super(ps, "s2");}} @Produces("text/s3") - public static class S3 extends DummySerializer { public S3() {super("s3");}} + public static class S3 extends DummySerializer { public S3(PropertyStore ps) {super(ps, "s3");}} /** * Test that default Accept and Content-Type headers on servlet annotation are picked up. @@ -104,10 +104,14 @@ public class DefaultContentTypesResource extends RestServlet { } public static class DummyParser extends ReaderParser { + private String name; - private DummyParser(String name) { + + private DummyParser(PropertyStore propertyStore, String name) { + super(propertyStore); this.name = name; } + @SuppressWarnings("unchecked") @Override /* Parser */ protected <T> T doParse(ParserSession session, ClassMeta<T> type) throws Exception { @@ -116,10 +120,14 @@ public class DefaultContentTypesResource extends RestServlet { } public static class DummySerializer extends WriterSerializer { + private String name; - private DummySerializer(String name) { + + private DummySerializer(PropertyStore propertyStore, String name) { + super(propertyStore); this.name = name; } + @Override /* Serializer */ protected void doSerialize(SerializerSession session, Object output) throws Exception { session.getWriter().write(name + "/" + output);
