Call setMaxPendingBytesPerConnection() at the right time.
Use getHostName instead of getHostString for JDK5 compat
Properly initialize AsyncHttpClientConfigBean.ioThreadMultiplier

Otherwise, Netty provider will crash as worker count will be 0
Standalone test shouldn't target http://foo.com
Improvements to the FeedableBodyGenerator (Grizzly's).
 - Don't allow queueing of data before initiateAsyncTransfer has been invoked.  In low memory
    heaps, this could lead to an OOM if the source is feeding too fast.  The new behavior is to
    block until initiateAsyncTransfer is called, at which time the blocked thread may proceed with
    the feed operation.
 - Introduce the concept of a Feeder.  Implementations are responsible, at a high level, for:
       + letting the provider know that data is available to be fed without blocking
       + allowing the registration of a callback that the Feeder implementation may invoke
          to signal that more data is available, if it wasn't available at a previous point in time.
 - When using a Feeder with a secure request, the SSL handshake will be kicked off by the
    initiateAsyncTransfer call, but feeding of data will not occur until the handshake is complete.
    This is necessary as the SSLFilter will queue up all writes until the handshake is complete,
    and currently, the buffer isn't tied in with the transport flow control mechanism.
    NOTE:  This new SSL behavior is not currently applied when invoking the feed() method
    outside the context of a Feeder.  Still need to address that.
  - Exposed configuration of the async write queue limit through the FeedableBodyGenerator.
     This is an improvement on using a TransportCustomizer as any configuration there is
     transport-wide, and therefor applied to all Connections.  By exposing it here, each feeder
     may have a different byte limit.
 - Improved documentation for this class
Missed print.
Another round of refactoring of the FeedableBodyGenerator based on Feedback on the Grizzly user list.

 - Removed FeedableBodyGenerator.feed().  This method is now defined by the Feeder interface and implemented by the BaseFeeder abstract class.
 - The original Feeder is no called NonBlockingFeeder.
 - Added SimpleFeeder that is a simple callback notifying the implementation that asyncronous
    transferring has been initiated.  This allows for feeding in the same fashion as the
    original FeedableBodyGenerator implementation, but doesn't suffer from some of the
    drawbacks (like unbound feeding before transferring has started or causing an OOM due
    to feeding large amounts of data while performing an SSL handshake.
Adjust when flag is set.
Fix invalid string ref.
Deal with the case when the connection is cached.
Fix the SSLHandshakeListener.  Need to discriminate the connection.