Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.logging.log4j.core.appender.db
Class AbstractDatabaseManager

    java.lang.Object
      org.apache.logging.log4j.core.appender.AbstractManager
          org.apache.logging.log4j.core.appender.db.AbstractDatabaseManager

All Implemented Interfaces:
  Flushable

Direct Known Subclasses:
  JdbcDatabaseManager, JpaDatabaseManager

    public abstract class AbstractDatabaseManager

extends AbstractManager
implements Flushable

Manager that allows database appenders to have their configuration reloaded without losing events.

Nested Class Summary
`protected static class` | `AbstractDatabaseManager.AbstractFactoryData` Implementations should extend this class for passing data between the getManager method and the manager factory class.

Field Summary

Fields inherited from class org.apache.logging.log4j.core.appender.AbstractManager
`count, LOGGER`

Constructor Summary
`protected` | `AbstractDatabaseManager(String name, int bufferSize)` Instantiates the base manager.

Method Summary
`protected abstract void` | `commitAndClose()` Commits any active transaction (if applicable) and disconnects from the database (returns the connection to the connection pool).
`protected abstract void` | `connectAndStart()` Connects to the database and starts a transaction (if applicable).
`void` | `flush()` This method is called automatically when the buffer size reaches its maximum or at the beginning of a call to `shutdown()`.
`protected static
`<M extends AbstractDatabaseManager,T extends AbstractDatabaseManager.AbstractFactoryData> M`
` | `getManager(String name, T data, ManagerFactory<M,T> factory)` Implementations should define their own getManager method and call this method from that to create or get existing managers.
`boolean` | `isRunning()` Indicates whether the manager is currently connected `startup()` has been called and `shutdown()` has not been called).
`void` | `releaseSub()` May be overridden by Managers to perform processing while the Manager is being released and the lock is held.
`void` | `shutdown()` This method is called from the `AbstractManager.release()` method when the appender is stopped or the appender's manager is replaced.
`protected abstract void` | `shutdownInternal()` Implementations should implement this method to perform any proprietary disconnection / shutdown operations.
`void` | `startup()` This method is called within the appender when the appender is started.
`protected abstract void` | `startupInternal()` Implementations should implement this method to perform any proprietary startup operations.
`String` | `toString()`
`void` | `write(LogEvent event)` This method manages buffering and writing of events.
`protected abstract void` | `writeInternal(LogEvent event)` Performs the actual writing of the event in an implementation-specific way.

Methods inherited from class org.apache.logging.log4j.core.appender.AbstractManager
`getContentFormat, getCount, getName, hasManager, release`

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

Constructor Detail

### AbstractDatabaseManager

    protected AbstractDatabaseManager(String name,
                                      int bufferSize)

  Instantiates the base manager.

  Parameters:
    `name` - The manager name, which should include any configuration details that one might want to be able to reconfigure at runtime, such as database name, username, (hashed) password, etc.
    `bufferSize` - The size of the log event buffer.

Method Detail

### startupInternal

    protected abstract void startupInternal()
                                     throws Exception

  Implementations should implement this method to perform any proprietary startup operations. This method will never be called twice on the same instance. It is safe to throw any exceptions from this method. This method does not necessarily connect to the database, as it is generally unreliable to connect once and use the same connection for hours.

  Throws:
    `Exception`

### startup

    public final void startup()

  This method is called within the appender when the appender is started. If it has not already been called, it calls `startupInternal()` and catches any exceptions it might throw.

### shutdownInternal

    protected abstract void shutdownInternal()
                                      throws Exception

  Implementations should implement this method to perform any proprietary disconnection / shutdown operations. This method will never be called twice on the same instance, and it will only be called after `startupInternal()`. It is safe to throw any exceptions from this method. This method does not necessarily disconnect from the database for the same reasons outlined in `startupInternal()`.

  Throws:
    `Exception`

### shutdown

    public final void shutdown()

  This method is called from the `AbstractManager.release()` method when the appender is stopped or the appender's manager is replaced. If it has not already been called, it calls `shutdownInternal()` and catches any exceptions it might throw.

### isRunning

    public final boolean isRunning()

  Indicates whether the manager is currently connected `startup()` has been called and `shutdown()` has not been called).

  Returns:
    `true` if the manager is connected.

### connectAndStart

    protected abstract void connectAndStart()

  Connects to the database and starts a transaction (if applicable). With buffering enabled, this is called when flushing the buffer begins, before the first call to `writeInternal(org.apache.logging.log4j.core.LogEvent)`. With buffering disabled, this is called immediately before every invocation of `writeInternal(org.apache.logging.log4j.core.LogEvent)`.

### writeInternal

    protected abstract void writeInternal(LogEvent event)

  Performs the actual writing of the event in an implementation-specific way. This method is called immediately from `write(LogEvent)` if buffering is off, or from `flush()` if the buffer has reached its limit.

  Parameters:
    `event` - The event to write to the database.

### commitAndClose

    protected abstract void commitAndClose()

  Commits any active transaction (if applicable) and disconnects from the database (returns the connection to the connection pool). With buffering enabled, this is called when flushing the buffer completes, after the last call to `writeInternal(org.apache.logging.log4j.core.LogEvent)`. With buffering disabled, this is called immediately after every invocation of `writeInternal(org.apache.logging.log4j.core.LogEvent)`.

### flush

    public final void flush()

  This method is called automatically when the buffer size reaches its maximum or at the beginning of a call to `shutdown()`. It can also be called manually to flush events to the database.

  Specified by:
    `flush` in interface `Flushable`

### write

    public final void write(LogEvent event)

  This method manages buffering and writing of events.

  Parameters:
    `event` - The event to write to the database.

### releaseSub

    public final void releaseSub()

  Description copied from class: `AbstractManager`
  May be overridden by Managers to perform processing while the Manager is being released and the lock is held.

  Overrides:
    `releaseSub` in class `AbstractManager`

### toString

    public final String toString()

  Overrides:
    `toString` in class `Object`

### getManager

    protected static <M extends AbstractDatabaseManager,T extends AbstractDatabaseManager.AbstractFactoryData> M getManager(String name,
                                                                                                                            T data,
                                                                                                                            ManagerFactory<M,T> factory)

  Implementations should define their own getManager method and call this method from that to create or get existing managers.

  Type Parameters:
    `M` - The concrete manager type.
    `T` - The concrete `AbstractDatabaseManager.AbstractFactoryData` type.
  Parameters:
    `name` - The manager name, which should include any configuration details that one might want to be able to reconfigure at runtime, such as database name, username, (hashed) password, etc.
    `data` - The concrete instance of `AbstractDatabaseManager.AbstractFactoryData` appropriate for the given manager.
    `factory` - A factory instance for creating the appropriate manager.
  Returns:
    a new or existing manager of the specified type and name.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 1999-2015 Apache Software Foundation. All Rights Reserved.
Apache Logging, Apache Log4j, Log4j, Apache, the Apache feather logo, the Apache Logging project logo, and the Apache Log4j logo are trademarks of The Apache Software Foundation.