## com.mysql.jdbc
Class LoadBalancingConnectionProxy

    java.lang.Object
      com.mysql.jdbc.LoadBalancingConnectionProxy

All Implemented Interfaces:
  PingTarget, java.lang.reflect.InvocationHandler

    public class LoadBalancingConnectionProxy

extends java.lang.Object
implements java.lang.reflect.InvocationHandler, PingTarget

An implementation of java.sql.Connection that load balances requests across a series of MySQL JDBC connections, where the balancing takes place at transaction commit. Therefore, for this to work (at all), you must use transactions, even if only reading data. This implementation will invalidate connections that it detects have had communication errors when processing a request. A new connection to the problematic host will be attempted the next time it is selected by the load balancing algorithm. This implementation is thread-safe, but it's questionable whether sharing a connection instance amongst threads is a good idea, given that transactions are scoped to connections in JDBC.

Nested Class Summary
`(package private) static interface` `LoadBalancingConnectionProxy.BalanceStrategy`
`(package private) class` `LoadBalancingConnectionProxy.BestResponseTimeBalanceStrategy`
`protected class` `LoadBalancingConnectionProxy.ConnectionErrorFiringInvocationHandler`
`(package private) class` `LoadBalancingConnectionProxy.RandomBalanceStrategy`

Field Summary
`(package private) LoadBalancingConnectionProxy.BalanceStrategy` `balancer`
`(package private) boolean` `inTransaction`
`(package private) boolean` `isClosed`
`(package private) java.util.Properties` `localProps`
`(package private) long` `transactionStartTime`

Constructor Summary
`LoadBalancingConnectionProxy(java.util.List hosts, java.util.Properties props)` Creates a proxy for java.sql.Connection that routes requests between the given list of host:port and uses the given properties when creating connections.

Method Summary
`(package private) void` `dealWithInvocationException(java.lang.reflect.InvocationTargetException e)`
`void` `doPing()`
`(package private) void` `invalidateCurrentConnection()` Closes current connection and removes it from required mappings.
`java.lang.Object` `invoke(java.lang.Object proxy, java.lang.reflect.Method method, java.lang.Object[] args)` Proxies method invocation on the java.sql.Connection interface, trapping "close", "isClosed" and "commit/rollback" (to switch connections for load balancing).
`(package private) java.lang.Object` `proxyIfInterfaceIsJdbc(java.lang.Object toProxy, java.lang.Class clazz)` Recursively checks for interfaces on the given object to determine if it implements a java.sql interface, and if so, proxies the instance so that we can catch and fire SQL errors.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### inTransaction

    boolean inTransaction

### transactionStartTime

    long transactionStartTime

### localProps

    java.util.Properties localProps

### isClosed

    boolean isClosed

### balancer

    LoadBalancingConnectionProxy.BalanceStrategy balancer

Constructor Detail

### LoadBalancingConnectionProxy

    LoadBalancingConnectionProxy(java.util.List hosts,
                                 java.util.Properties props)
                           throws java.sql.SQLException

  Creates a proxy for java.sql.Connection that routes requests between the given list of host:port and uses the given properties when creating connections.

  Parameters:
    `hosts` -
    `props` -
  Throws:
    `java.sql.SQLException`

Method Detail

### dealWithInvocationException

    void dealWithInvocationException(java.lang.reflect.InvocationTargetException e)
                               throws java.sql.SQLException,
                                      java.lang.Throwable,
                                      java.lang.reflect.InvocationTargetException

  Parameters:
    `e` -
  Throws:
    `java.sql.SQLException`
    `java.lang.Throwable`
    `java.lang.reflect.InvocationTargetException`

### invalidateCurrentConnection

    void invalidateCurrentConnection()
                               throws java.sql.SQLException

  Closes current connection and removes it from required mappings.

  Throws:
    `java.sql.SQLException`

### invoke

    public java.lang.Object invoke(java.lang.Object proxy,
                                   java.lang.reflect.Method method,
                                   java.lang.Object[] args)
                            throws java.lang.Throwable

  Proxies method invocation on the java.sql.Connection interface, trapping "close", "isClosed" and "commit/rollback" (to switch connections for load balancing).

  Specified by:
    `invoke` in interface `java.lang.reflect.InvocationHandler`
  Throws:
    `java.lang.Throwable`

### proxyIfInterfaceIsJdbc

    java.lang.Object proxyIfInterfaceIsJdbc(java.lang.Object toProxy,
                                            java.lang.Class clazz)

  Recursively checks for interfaces on the given object to determine if it implements a java.sql interface, and if so, proxies the instance so that we can catch and fire SQL errors.

  Parameters:
    `toProxy` -
    `clazz` -
  Returns:

### doPing

    public void doPing()
                throws java.sql.SQLException

  Specified by:
    `doPing` in interface `PingTarget`
  Throws:
    `java.sql.SQLException`