Connection management
17
This connection manager implementation should be used inside an EJB container.
2.3.3. Pooling connection manager
PoolingHttpClientConnectionManager
is a more complex implementation that manages a pool
of client connections and is able to service connection requests from multiple execution threads.
Connections are pooled on a per route basis. A request for a route for which the manager already has
a persistent connection available in the pool will be serviced by leasing a connection from the pool
rather than creating a brand new connection.
PoolingHttpClientConnectionManager
maintains a maximum limit of connections on a per route
basis and in total. Per default this implementation will create no more than 2 concurrent connections
per given route and no more 20 connections in total. For many real-world applications these limits
may prove too constraining, especially if they use HTTP as a transport protocol for their services.
This example shows how the connection pool parameters can be adjusted:
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
// Increase max total connection to 200
cm.setMaxTotal(200);
// Increase default max connection per route to 20
cm.setDefaultMaxPerRoute(20);
// Increase max connections for localhost:80 to 50
HttpHost localhost = new HttpHost("locahost", 80);
cm.setMaxPerRoute(new HttpRoute(localhost), 50);
CloseableHttpClient httpClient = HttpClients.custom()
.setConnectionManager(cm)
.build();
2.3.4. Connection manager shutdown
When an HttpClient instance is no longer needed and is about to go out of scope it is important to shut
down its connection manager to ensure that all connections kept alive by the manager get closed and
system resources allocated by those connections are released.
CloseableHttpClient httpClient = <...>
httpClient.close();
2.4. Multithreaded request execution
When equipped with a pooling connection manager such as 
PoolingClientConnectionManager
,
HttpClient can be used to execute multiple requests simultaneously using multiple threads of execution.
The 
PoolingClientConnectionManager
will allocate connections based on its configuration. If all
connections for a given route have already been leased, a request for a connection will block
until a connection is released back to the pool. One can ensure the connection manager does not
block indefinitely in the connection request operation by setting 
'http.conn-manager.timeout'
to a positive value. If the connection request cannot be serviced within the given time period
ConnectionPoolTimeoutException
will be thrown.
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
Reader convert pdf to jpg - Convert PDF to JPEG images in C#.net, ASP.NET MVC, WinForms, WPF project
How to convert PDF to JPEG using C#.NET PDF to JPEG conversion / converter library control SDK
convert pdf file to jpg; change format from pdf to jpg
Reader convert pdf to jpg - VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.net, ASP.NET MVC, WinForms, WPF project
Online Tutorial for PDF to JPEG (JPG) Conversion in VB.NET Image Application
convert pdf file to jpg format; change pdf to jpg
Connection management
18
CloseableHttpClient httpClient = HttpClients.custom()
.setConnectionManager(cm)
.build();
// URIs to perform GETs on
String[] urisToGet = {
"http://www.domain1.com/",
"http://www.domain2.com/",
"http://www.domain3.com/",
"http://www.domain4.com/"
};
// create a thread for each URI
GetThread[] threads = new GetThread[urisToGet.length];
for (int i = 0; i < threads.length; i++) {
HttpGet httpget = new HttpGet(urisToGet[i]);
threads[i] = new GetThread(httpClient, httpget);
}
// start the threads
for (int j = 0; j < threads.length; j++) {
threads[j].start();
}
// join the threads
for (int j = 0; j < threads.length; j++) {
threads[j].join();
}
While 
HttpClient
instances are thread safe and can be shared between multiple threads of execution,
it is highly recommended that each thread maintains its own dedicated instance of 
HttpContext 
.
static class GetThread extends Thread {
private final CloseableHttpClient httpClient;
private final HttpContext context;
private final HttpGet httpget;
public GetThread(CloseableHttpClient httpClient, HttpGet httpget) {
this.httpClient = httpClient;
this.context = HttpClientContext.create();
this.httpget = httpget;
}
@Override
public void run() {
try {
CloseableHttpResponse response = httpClient.execute(
httpget, context);
try {
HttpEntity entity = response.getEntity();
} finally {
response.close();
}
} catch (ClientProtocolException ex) {
// Handle protocol errors
} catch (IOException ex) {
// Handle I/O errors
}
}
}
C# Image Convert: How to Convert Adobe PDF to Jpeg, Png, Bmp, &
This demo code just converts first page to jpeg image. String inputFilePath = @"C:\input.pdf"; String outputFilePath = @"C:\output.jpg"; // Convert PDF to jpg.
convert .pdf to .jpg; convert pdf pages to jpg online
C# Image Convert: How to Convert Tiff Image to Jpeg, Png, Bmp, &
RasterEdge.XDoc.PDF.dll. This demo code will convert first page to jpeg image. C:\input.tif"; String outputFilePath = @"C:\output.jpg"; // Convert tiff to jpg.
convert pdf file into jpg format; convert multi page pdf to single jpg
Connection management
19
2.5. Connection eviction policy
One of the major shortcomings of the classic blocking I/O model is that the network socket can react to
I/O events only when blocked in an I/O operation. When a connection is released back to the manager,
it can be kept alive however it is unable to monitor the status of the socket and react to any I/O events.
If the connection gets closed on the server side, the client side connection is unable to detect the change
in the connection state (and react appropriately by closing the socket on its end).
HttpClient tries to mitigate the problem by testing whether the connection is 'stale', that is no
longer valid because it was closed on the server side, prior to using the connection for executing
an HTTP request. The stale connection check is not 100% reliable. The only feasible solution
that does not involve a one thread per socket model for idle connections is a dedicated monitor
thread used to evict connections that are considered expired due to a long period of inactivity.
The monitor thread can periodically call 
ClientConnectionManager#closeExpiredConnections()
method to close all expired connections and evict closed connections from the pool. It can also
optionally call 
ClientConnectionManager#closeIdleConnections()
method to close all connections
that have been idle over a given period of time.
public static class IdleConnectionMonitorThread extends Thread {
private final HttpClientConnectionManager connMgr;
private volatile boolean shutdown;
public IdleConnectionMonitorThread(HttpClientConnectionManager connMgr) {
super();
this.connMgr = connMgr;
}
@Override
public void run() {
try {
while (!shutdown) {
synchronized (this) {
wait(5000);
// Close expired connections
connMgr.closeExpiredConnections();
// Optionally, close connections
// that have been idle longer than 30 sec
connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
}
}
} catch (InterruptedException ex) {
// terminate
}
}
public void shutdown() {
shutdown = true;
synchronized (this) {
notifyAll();
}
}
}
C# Create PDF from images Library to convert Jpeg, png images to
Batch convert PDF documents from multiple image formats, including Jpg, Png, Bmp, Gif, Tiff, Bitmap, .NET Graphics, and REImage.
convert online pdf to jpg; convert pdf to jpg 300 dpi
VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
Resize converted image files in VB.NET. Convert PDF to Jpg, Png, Bmp, Gif, Tiff and Bitmap in ASP.NET. Embed PDF to image converter in viewer.
convert pdf to jpg for; changing pdf to jpg on
Connection management
20
2.6. Connection keep alive strategy
The HTTP specification does not specify how long a persistent connection may be and should be kept
alive. Some HTTP servers use a non-standard 
Keep-Alive
header to communicate to the client the
period of time in seconds they intend to keep the connection alive on the server side. HttpClient makes
use of this information if available. If the 
Keep-Alive
header is not present in the response, HttpClient
assumes the connection can be kept alive indefinitely. However, many HTTP servers in general use
are configured to drop persistent connections after a certain period of inactivity in order to conserve
system resources, quite often without informing the client. In case the default strategy turns out to be
too optimistic, one may want to provide a custom keep-alive strategy.
ConnectionKeepAliveStrategy myStrategy = new ConnectionKeepAliveStrategy() {
public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
// Honor 'keep-alive' header
HeaderElementIterator it = new BasicHeaderElementIterator(
response.headerIterator(HTTP.CONN_KEEP_ALIVE));
while (it.hasNext()) {
HeaderElement he = it.nextElement();
String param = he.getName();
String value = he.getValue();
if (value != null && param.equalsIgnoreCase("timeout")) {
try {
return Long.parseLong(value) * 1000;
} catch(NumberFormatException ignore) {
}
}
}
HttpHost target = (HttpHost) context.getAttribute(
HttpClientContext.HTTP_TARGET_HOST);
if ("www.naughty-server.com".equalsIgnoreCase(target.getHostName())) {
// Keep alive for 5 seconds only
return 5 * 1000;
} else {
// otherwise keep alive for 30 seconds
return 30 * 1000;
}
}
};
CloseableHttpClient client = HttpClients.custom()
.setKeepAliveStrategy(myStrategy)
.build();
2.7. Connection socket factories
HTTP connections make use of a 
java.net.Socket
object internally to handle transmission of data
across the wire. However they rely on the 
ConnectionSocketFactory
interface to create, initialize
and connect sockets. This enables the users of HttpClient to provide application specific socket
initialization code at runtime. 
PlainConnectionSocketFactory
is the default factory for creating and
initializing plain (unencrypted) sockets.
The process of creating a socket and that of connecting it to a host are decoupled, so that the socket
could be closed while being blocked in the connect operation.
HttpClientContext clientContext = HttpClientContext.create();
PlainConnectionSocketFactory sf = PlainConnectionSocketFactory.getSocketFactory();
C# TIFF: C#.NET Code to Convert JPEG Images to TIFF
Use C# Code to Convert Jpeg to Tiff. string[] imagePaths = { @"C:\demo1.jpg", @"C:\demo2.jpg", @"C:\demo3.jpg" }; // Construct List<REImage> object.
convert pdf document to jpg; best pdf to jpg converter
VB.NET PDF - Convert PDF with VB.NET WPF PDF Viewer
Barcoding. XImage.Barcode Reader. XImage.Barcode Generator. Others. XDoc.Tiff. XDoc.Dicom. 4. To Image. Convert PDF to image formats, such as PNG, JPG, BMP and
change pdf file to jpg; convert pdf to jpg for online
Connection management
21
Socket socket = sf.createSocket(clientContext);
int timeout = 1000; //ms
HttpHost target = new HttpHost("localhost");
InetSocketAddress remoteAddress = new InetSocketAddress(
InetAddress.getByAddress(new byte[] {127,0,0,1}), 80);
sf.connectSocket(timeout, socket, target, remoteAddress, null, clientContext);
2.7.1. Secure socket layering
LayeredConnectionSocketFactory
is an extension of the 
ConnectionSocketFactory
interface.
Layered socket factories are capable of creating sockets layered over an existing plain socket.
Socket layering is used primarily for creating secure sockets through proxies. HttpClient ships with
SSLSocketFactory
that implements SSL/TLS layering. Please note HttpClient does not use any custom
encryption functionality. It is fully reliant on standard Java Cryptography (JCE) and Secure Sockets
(JSEE) extensions.
2.7.2. Integration with connection manager
Custom connection socket factories can be associated with a particular protocol scheme as as HTTP
or HTTPS and then used to create a custom connection manager.
ConnectionSocketFactory plainsf = <...>
LayeredConnectionSocketFactory sslsf = <...>
Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", plainsf)
.register("https", sslsf)
.build();
HttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(r);
HttpClients.custom()
.setConnectionManager(cm)
.build();
2.7.3. SSL/TLS customization
HttpClient makes use of 
SSLConnectionSocketFactory
to create SSL connections.
SSLConnectionSocketFactory
allows for a high degree of customization. It can take an instance of
javax.net.ssl.SSLContext
as a parameter and use it to create custom configured SSL connections.
KeyStore myTrustStore = <...>
SSLContext sslContext = SSLContexts.custom()
.loadTrustMaterial(myTrustStore)
.build();
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);
Customization of 
SSLConnectionSocketFactory
implies a certain degree of familiarity with
the concepts of the SSL/TLS protocol, a detailed explanation of which is out of scope
for this document. Please refer to the  Java™ Secure Socket Extension (JSSE) Reference
Guide [http://docs.oracle.com/javase/6/docs/technotes/guides/security/jsse/JSSERefGuide.html] for a
detailed description of 
javax.net.ssl.SSLContext
and related tools.
2.7.4. Hostname verification
In addition to the trust verification and the client authentication performed on the SSL/
TLS protocol level, HttpClient can optionally verify whether the target hostname matches the
C# WPF PDF Viewer SDK to convert and export PDF document to other
Barcoding. XImage.Barcode Reader. XImage.Barcode Generator. Others. XDoc.Tiff. XDoc.Dicom. 4. To Image. Convert PDF to image formats, such as PNG, JPG, BMP and
convert multipage pdf to jpg; convert pdf picture to jpg
VB.NET Create PDF from images Library to convert Jpeg, png images
Components to batch convert PDF documents in Visual Basic .NET class. Support create PDF from multiple image formats in VB.NET, including Jpg, Png, Bmp, Gif
convert multiple pdf to jpg; convert multiple page pdf to jpg
Connection management
22
names stored inside the server's X.509 certificate, once the connection has been established.
This verification can provide additional guarantees of authenticity of the server trust material.
The 
javax.net.ssl.HostnameVerifier
interface represents a strategy for hostname verification.
HttpClient ships with two 
javax.net.ssl.HostnameVerifier
implementations. Important: hostname
verification should not be confused with SSL trust verification.
DefaultHostnameVerifier
 The default implementation used by HttpClient is expected to be
compliant with RFC 2818. The hostname must match any of alternative names specified by the
certificate, or in case no alternative names are given the most specific CN of the certificate subject.
A wildcard can occur in the CN, and in any of the subject-alts.
NoopHostnameVerifier
 This hostname verifier essentially turns hostname verification off. It
accepts any SSL session as valid and matching the target host.
Per default HttpClient uses the 
DefaultHostnameVerifier
implementation. One can specify a
different hostname verifier implementation if desired
SSLContext sslContext = SSLContexts.createSystemDefault();
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
sslContext,
NoopHostnameVerifier.INSTANCE);
As of version 4.4 HttpClient uses the public suffix list kindly maintained by Mozilla Foundation to
make sure that wildcards in SSL certificates cannot be misused to apply to multiple domains with a
common top-level domain. HttpClient ships with a copy of the list retrieved at the time of the release.
The latest revision of the list can found at  https://publicsuffix.org/list/ [https://publicsuffix.org/list/
effective_tld_names.dat]. It is highly adviseable to make a local copy of the list and download the list
no more than once per day from its original location.
PublicSuffixMatcher publicSuffixMatcher = PublicSuffixMatcherLoader.load(
PublicSuffixMatcher.class.getResource("my-copy-effective_tld_names.dat"));
DefaultHostnameVerifier hostnameVerifier = new DefaultHostnameVerifier(publicSuffixMatcher);
One can disable verification against the public suffic list by using 
null
matcher.
DefaultHostnameVerifier hostnameVerifier = new DefaultHostnameVerifier(null);
2.8. HttpClient proxy configuration
Even though HttpClient is aware of complex routing schemes and proxy chaining, it supports only
simple direct or one hop proxy connections out of the box.
The simplest way to tell HttpClient to connect to the target host via a proxy is by setting the default
proxy parameter:
HttpHost proxy = new HttpHost("someproxy", 8080);
DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);
CloseableHttpClient httpclient = HttpClients.custom()
.setRoutePlanner(routePlanner)
.build();
One can also instruct HttpClient to use the standard JRE proxy selector to obtain proxy information:
Connection management
23
SystemDefaultRoutePlanner routePlanner = new SystemDefaultRoutePlanner(
ProxySelector.getDefault());
CloseableHttpClient httpclient = HttpClients.custom()
.setRoutePlanner(routePlanner)
.build();
Alternatively, one can provide a custom 
RoutePlanner
implementation in order to have a complete
control over the process of HTTP route computation:
HttpRoutePlanner routePlanner = new HttpRoutePlanner() {
public HttpRoute determineRoute(
HttpHost target,
HttpRequest request,
HttpContext context) throws HttpException {
return new HttpRoute(target, null,  new HttpHost("someproxy", 8080),
"https".equalsIgnoreCase(target.getSchemeName()));
}
};
CloseableHttpClient httpclient = HttpClients.custom()
.setRoutePlanner(routePlanner)
.build();
}
}
24
Chapter 3. HTTP state management
Originally HTTP was designed as a stateless, request / response oriented protocol that made no special
provisions for stateful sessions spanning across several logically related request / response exchanges.
As HTTP protocol grew in popularity and adoption more and more systems began to use it for
applications it was never intended for, for instance as a transport for e-commerce applications. Thus,
the support for state management became a necessity.
Netscape Communications, at that time a leading developer of web client and server software,
implemented support for HTTP state management in their products based on a proprietary
specification. Later, Netscape tried to standardise the mechanism by publishing a specification draft.
Those efforts contributed to the formal specification defined through the RFC standard track. However,
state management in a significant number of applications is still largely based on the Netscape draft and
is incompatible with the official specification. All major developers of web browsers felt compelled
to retain compatibility with those applications greatly contributing to the fragmentation of standards
compliance.
3.1. HTTP cookies
An HTTP cookie is a token or short packet of state information that the HTTP agent and the target
server can exchange to maintain a session. Netscape engineers used to refer to it as a "magic cookie"
and the name stuck.
HttpClient uses the 
Cookie
interface to represent an abstract cookie token. In its simplest form an HTTP
cookie is merely a name / value pair. Usually an HTTP cookie also contains a number of attributes
such a domain for which is valid, a path that specifies the subset of URLs on the origin server to which
this cookie applies, and the maximum period of time for which the cookie is valid.
The 
SetCookie
interface represents a 
Set-Cookie
response header sent by the origin server to the
HTTP agent in order to maintain a conversational state.
The 
ClientCookie
interface extends 
Cookie
interface with additional client specific functionality
such as the ability to retrieve original cookie attributes exactly as they were specified by the origin
server. This is important for generating the 
Cookie
header because some cookie specifications require
that the 
Cookie
header should include certain attributes only if they were specified in the 
Set-Cookie
header.
Here is an example of creating a client-side cookie object:
BasicClientCookie cookie = new BasicClientCookie("name", "value");
// Set effective domain and path attributes
cookie.setDomain(".mycompany.com");
cookie.setPath("/");
// Set attributes exactly as sent by the server
cookie.setAttribute(ClientCookie.PATH_ATTR, "/");
cookie.setAttribute(ClientCookie.DOMAIN_ATTR, ".mycompany.com");
3.2. Cookie specifications
The 
CookieSpec
interface represents a cookie management specification. The cookie management
specification is expected to enforce:
HTTP state management
25
• rules of parsing 
Set-Cookie
headers.
• rules of validation of parsed cookies.
• formatting of 
Cookie
header for a given host, port and path of origin.
HttpClient ships with several 
CookieSpec
implementations:
• Standard strict:  State management policy compliant with the syntax and semantics of the well-
behaved profile defined by RFC 6265, section 4.
• Standard:  State management policy compliant with a more relaxed profile defined by RFC
6265, section 4 intended for interoperability with existing servers that do not conform to the well
behaved profile.
• Netscape draft (obsolete):  This policy conforms to the original draft specification published
by Netscape Communications. It should be avoided unless absolutely necessary for compatibility
with legacy code.
• RFC 2965 (obsolete):  State management policy compliant with the obsolete state management
specification defined by RFC 2965. Please do not use in new applications.
• RFC 2109 (obsolete):  State management policy compliant with the obsolete state management
specification defined by RFC 2109. Please do not use in new applications.
• Browser compatibility (obsolete):  This policy strives to closely mimic the (mis)behavior of
older versions of browser applications such as Microsoft Internet Explorer and Mozilla FireFox.
Please do not use in new applications.
• Default:  Default cookie policy is a synthetic policy that picks up either RFC 2965, RFC 2109
or Netscape draft compliant implementation based on properties of cookies sent with the HTTP
response (such as version attribute, now obsolete). This policy will be deprecated in favor of the
standard (RFC 6265 compliant) implementation in the next minor release of HttpClient.
• Ignore cookies:  All cookies are ignored.
It is strongly recommended to use either 
Standard
or 
Standard strict
policy in new applications.
Obsolete specifications should be used for compatibility with legacy systems only. Support for obsolete
specifications will be removed in the next major release of HttpClient.
3.3. Choosing cookie policy
Cookie policy can be set at the HTTP client and overridden on the HTTP request level if required.
RequestConfig globalConfig = RequestConfig.custom()
.setCookieSpec(CookieSpecs.DEFAULT)
.build();
CloseableHttpClient httpclient = HttpClients.custom()
.setDefaultRequestConfig(globalConfig)
.build();
RequestConfig localConfig = RequestConfig.copy(globalConfig)
.setCookieSpec(CookieSpecs.STANDARD_STRICT)
.build();
HTTP state management
26
HttpGet httpGet = new HttpGet("/");
httpGet.setConfig(localConfig);
3.4. Custom cookie policy
In order to implement a custom cookie policy one should create a custom implementation of the
CookieSpec
interface, create a 
CookieSpecProvider
implementation to create and initialize instances
of the custom specification and register the factory with HttpClient. Once the custom specification has
been registered, it can be activated the same way as a standard cookie specification.
PublicSuffixMatcher publicSuffixMatcher = PublicSuffixMatcherLoader.getDefault();
Registry<CookieSpecProvider> r = RegistryBuilder.<CookieSpecProvider>create()
.register(CookieSpecs.DEFAULT,
new DefaultCookieSpecProvider(publicSuffixMatcher))
.register(CookieSpecs.STANDARD,
new RFC6265CookieSpecProvider(publicSuffixMatcher))
.register("easy", new EasySpecProvider())
.build();
RequestConfig requestConfig = RequestConfig.custom()
.setCookieSpec("easy")
.build();
CloseableHttpClient httpclient = HttpClients.custom()
.setDefaultCookieSpecRegistry(r)
.setDefaultRequestConfig(requestConfig)
.build();
3.5. Cookie persistence
HttpClient can work with any physical representation of a persistent cookie store that implements
the 
CookieStore
interface. The default 
CookieStore
implementation called 
BasicCookieStore
is a
simple implementation backed by a 
java.util.ArrayList
. Cookies stored in an 
BasicClientCookie
object are lost when the container object get garbage collected. Users can provide more complex
implementations if necessary.
// Create a local instance of cookie store
CookieStore cookieStore = new BasicCookieStore();
// Populate cookies if needed
BasicClientCookie cookie = new BasicClientCookie("name", "value");
cookie.setDomain(".mycompany.com");
cookie.setPath("/");
cookieStore.addCookie(cookie);
// Set the store
CloseableHttpClient httpclient = HttpClients.custom()
.setDefaultCookieStore(cookieStore)
.build();
3.6. HTTP state management and execution context
In the course of HTTP request execution HttpClient adds the following state management related
objects to the execution context:
Lookup
instance representing the actual cookie specification registry. The value of this attribute set
in the local context takes precedence over the default one.
Documents you may be interested
Documents you may be interested