java.lang.Object
- org.springframework.web.socket.client.ConnectionManagerSupport

All Implemented Interfaces:
Lifecycle, Phased, SmartLifecycle
Direct Known Subclasses:
AnnotatedEndpointConnectionManager, EndpointConnectionManager, WebSocketConnectionManager
```
public abstract class ConnectionManagerSupport
extends Object
implements SmartLifecycle
```
A base class for WebSocket connection managers. Provides a declarative style of connecting to a WebSocket server given a URI to connect to. The connection occurs when the Spring ApplicationContext is refreshed, if the autoStartup property is set to true, or if set to false, the start() and #stop methods can be invoked manually.
Since:
4.0
Author:
Rossen Stoyanchev

Field Summary
Fields
Modifier and Type Field Description
protected Log logger
- Fields inherited from interface org.springframework.context.SmartLifecycle
  DEFAULT_PHASE

Constructor Summary
Constructors
Constructor Description
ConnectionManagerSupport(String uriTemplate, Object... uriVariables)

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`protected abstract void`	`closeConnection()`
`int`	`getPhase()`	Return the phase in which this endpoint connection factory will be auto-connected and stopped.
`protected URI`	`getUri()`
`boolean`	`isAutoStartup()`	Return the value for the 'autoStartup' property.
`protected abstract boolean`	`isConnected()`
`boolean`	`isRunning()`	Return whether this ConnectionManager has been started.
`protected abstract void`	`openConnection()`
`void`	`setAutoStartup(boolean autoStartup)`	Set whether to auto-connect to the remote endpoint after this connection manager has been initialized and the Spring context has been refreshed.
`void`	`setPhase(int phase)`	Specify the phase in which a connection should be established to the remote endpoint and subsequently closed.
`void`	`start()`	Start the WebSocket connection.
`protected void`	`startInternal()`
`void`	`stop()`	Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method.
`void`	`stop(Runnable callback)`	Indicates that a Lifecycle component must stop if it is currently running.
`protected void`	`stopInternal()`

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

- Field Detail
  - logger
```
protected final Log logger
```
- Constructor Detail
  - ConnectionManagerSupport
```
public ConnectionManagerSupport(String uriTemplate,
                                Object... uriVariables)
```
- Method Detail
  - getUri
```
protected URI getUri()
```
  - setAutoStartup
```
public void setAutoStartup(boolean autoStartup)
```
    Set whether to auto-connect to the remote endpoint after this connection manager has been initialized and the Spring context has been refreshed.
    Default is "false".
  - isAutoStartup
```
public boolean isAutoStartup()
```
    Return the value for the 'autoStartup' property. If "true", this endpoint connection manager will connect to the remote endpoint upon a ContextRefreshedEvent.
    Specified by:
    isAutoStartup in interface SmartLifecycle
    See Also:
    Lifecycle.start(), SmartLifecycle.getPhase(), LifecycleProcessor.onRefresh(), ConfigurableApplicationContext.refresh()
  - setPhase
```
public void setPhase(int phase)
```
    Specify the phase in which a connection should be established to the remote endpoint and subsequently closed. The startup order proceeds from lowest to highest, and the shutdown order is the reverse of that. By default this value is Integer.MAX_VALUE meaning that this endpoint connection factory connects as late as possible and is closed as soon as possible.
  - getPhase
```
public int getPhase()
```
    Return the phase in which this endpoint connection factory will be auto-connected and stopped.
    Specified by:
    getPhase in interface Phased
    Specified by:
    getPhase in interface SmartLifecycle
    See Also:
    SmartLifecycle.isAutoStartup(), Lifecycle.start(), SmartLifecycle.stop(Runnable), DefaultLifecycleProcessor.getPhase(Lifecycle)
  - start
```
public final void start()
```
    Start the WebSocket connection. If already connected, the method has no impact.
    Specified by:
    start in interface Lifecycle
    See Also:
    SmartLifecycle.isAutoStartup()
  - startInternal
```
protected void startInternal()
```
  - stop
```
public final void stop()
```
    Description copied from interface: Lifecycle
    Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method. Consider implementing SmartLifecycle and its stop(Runnable) variant when asynchronous stop behavior is necessary.
    Note that this stop notification is not guaranteed to come before destruction: On regular shutdown, Lifecycle beans will first receive a stop notification before the general destruction callbacks are being propagated; however, on hot refresh during a context's lifetime or on aborted refresh attempts, a given bean's destroy method will be called without any consideration of stop signals upfront.
    Should not throw an exception if the component is not running (not started yet).
    In the case of a container, this will propagate the stop signal to all components that apply.
    Specified by:
    stop in interface Lifecycle
    See Also:
    SmartLifecycle.stop(Runnable), DisposableBean.destroy()
  - stop
```
public final void stop(Runnable callback)
```
    Description copied from interface: SmartLifecycle
    Indicates that a Lifecycle component must stop if it is currently running.
    The provided callback is used by the LifecycleProcessor to support an ordered, and potentially concurrent, shutdown of all components having a common shutdown order value. The callback must be executed after the SmartLifecycle component does indeed stop.
    The LifecycleProcessor will call only this variant of the stop method; i.e. Lifecycle.stop() will not be called for SmartLifecycle implementations unless explicitly delegated to within the implementation of this method.
    The default implementation delegates to Lifecycle.stop() and immediately triggers the given callback in the calling thread. Note that there is no synchronization between the two, so custom implementations may at least want to put the same steps within their common lifecycle monitor (if any).
    Specified by:
    stop in interface SmartLifecycle
    See Also:
    Lifecycle.stop(), SmartLifecycle.getPhase()
  - stopInternal
```
protected void stopInternal()
                     throws Exception
```
    Throws:
    Exception
  - isRunning
```
public boolean isRunning()
```
    Return whether this ConnectionManager has been started.
    Specified by:
    isRunning in interface Lifecycle
    Returns:
    whether the component is currently running
  - openConnection
```
protected abstract void openConnection()
```
  - closeConnection
```
protected abstract void closeConnection()
                                 throws Exception
```
    Throws:
    Exception
  - isConnected
```
protected abstract boolean isConnected()
```

Class ConnectionManagerSupport

Field Summary

Fields inherited from interface org.springframework.context.SmartLifecycle

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

ConnectionManagerSupport

Method Detail

getUri

setAutoStartup

isAutoStartup

setPhase

getPhase

start

startInternal

stop

stop

stopInternal

isRunning

openConnection

closeConnection

isConnected