ch.qos.logback.core

## Class OutputStreamAppender<E>

- java.lang.Object
- - ch.qos.logback.core.spi.ContextAwareBase
  - - ch.qos.logback.core.UnsynchronizedAppenderBase<E>
    - - ch.qos.logback.core.OutputStreamAppender<E>

All Implemented Interfaces:
  Appender<E>, ContextAware, FilterAttachable<E>, LifeCycle

Direct Known Subclasses:
  ConsoleAppender, FileAppender

    public class OutputStreamAppender<E>
    extends UnsynchronizedAppenderBase<E>

OutputStreamAppender appends events to a `OutputStream`. This class provides basic services that other appenders build upon. For more information about this appender, please refer to the online manual at http://logback.qos.ch/manual/appenders.html#OutputStreamAppender

Author:
  Ceki Gülcü

### Field Summary

Fields
`protected Encoder<E>` `encoder` It is the encoder which is ultimately responsible for writing the event to an `OutputStream`.
`protected java.util.concurrent.locks.ReentrantLock` `lock` All synchronization in this class is done via the lock object.

### Fields inherited from class ch.qos.logback.core.UnsynchronizedAppenderBase

`name, started`

### Fields inherited from class ch.qos.logback.core.spi.ContextAwareBase

`context`

### Constructor Summary

Constructors
Constructor and Description
`OutputStreamAppender()`

### Method Summary

Methods
`protected void` `append(E eventObject)`
`protected void` `closeOutputStream()` Close the underlying `OutputStream`.
`Encoder<E>` `getEncoder()`
`java.io.OutputStream` `getOutputStream()` The underlying output stream used by this appender.
`void` `setEncoder(Encoder<E> encoder)`
`void` `setLayout(Layout<E> layout)`
`void` `setOutputStream(java.io.OutputStream outputStream)` Sets the @link OutputStream} where the log output will go.
`void` `start()` Checks that requires parameters are set and if everything is in order, activates this appender.
`void` `stop()` Stop this appender instance.
`protected void` `subAppend(E event)` Actual writing occurs here.
`protected void` `writeOut(E event)`

### Methods inherited from class ch.qos.logback.core.UnsynchronizedAppenderBase

`addFilter, clearAllFilters, doAppend, getCopyOfAttachedFiltersList, getFilterChainDecision, getName, isStarted, setName, toString`

### Methods inherited from class ch.qos.logback.core.spi.ContextAwareBase

`addError, addError, addInfo, addInfo, addStatus, addWarn, addWarn, getContext, getDeclaredOrigin, getStatusManager, setContext`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface ch.qos.logback.core.spi.ContextAware

`addError, addError, addInfo, addInfo, addStatus, addWarn, addWarn, getContext, setContext`

### Field Detail

#### encoder

    protected Encoder<E> encoder

It is the encoder which is ultimately responsible for writing the event to an `OutputStream`.

#### lock

    protected final java.util.concurrent.locks.ReentrantLock lock

All synchronization in this class is done via the lock object.

### Constructor Detail

#### OutputStreamAppender

    public OutputStreamAppender()

### Method Detail

#### getOutputStream

    public java.io.OutputStream getOutputStream()

The underlying output stream used by this appender.

Returns:

#### start

    public void start()

Checks that requires parameters are set and if everything is in order, activates this appender.

Specified by:
  `start` in interface `LifeCycle`
Overrides:
  `start` in class `UnsynchronizedAppenderBase<E>`

#### setLayout

    public void setLayout(Layout<E> layout)

#### append

    protected void append(E eventObject)

Specified by:
  `append` in class `UnsynchronizedAppenderBase<E>`

#### stop

    public void stop()

Stop this appender instance. The underlying stream or writer is also closed.

Stopped appenders cannot be reused.

Specified by:
  `stop` in interface `LifeCycle`
Overrides:
  `stop` in class `UnsynchronizedAppenderBase<E>`

#### closeOutputStream

    protected void closeOutputStream()

Close the underlying `OutputStream`.

#### setOutputStream

    public void setOutputStream(java.io.OutputStream outputStream)

Sets the @link OutputStream} where the log output will go. The specified `OutputStream` must be opened by the user and be writable. The `OutputStream` will be closed when the appender instance is closed.

Parameters:
  `outputStream` - An already opened OutputStream.

#### writeOut

    protected void writeOut(E event)
                     throws java.io.IOException

Throws:
  `java.io.IOException`

#### subAppend

    protected void subAppend(E event)

Actual writing occurs here.

Most subclasses of `WriterAppender` will need to override this method.

Since:
  0.9.0

#### getEncoder

    public Encoder<E> getEncoder()

#### setEncoder

    public void setEncoder(Encoder<E> encoder)