Added in API level 1

Summary: Protected Ctors | Methods | Protected Methods | Inherited Methods

Handler

public abstract class Handler
extends Object

java.lang.Object
↳	java.util.logging.Handler

Known direct subclasses

MemoryHandler, StreamHandler

MemoryHandler	`Handler` that buffers requests in a circular buffer in memory.
StreamHandler	Stream based logging `Handler`.

Known indirect subclasses

ConsoleHandler, FileHandler, SocketHandler

ConsoleHandler	This `Handler` publishes log records to `System.err`.
FileHandler	Simple file logging `Handler`.
SocketHandler	Simple network logging `Handler`.

A Handler object takes log messages from a Logger and exports them. It might for example, write them to a console or write them to a file, or send them to a network logging service, or forward them to an OS log, or whatever.

A Handler can be disabled by doing a setLevel(Level.OFF) and can be re-enabled by doing a setLevel with an appropriate level.

Handler classes typically use LogManager properties to set default values for the Handler's Filter, Formatter, and Level. See the specific documentation for each concrete Handler class.

Summary

Protected constructors
`Handler()` Default constructor.

Public methods
`abstract void`	`close()` Close the `Handler` and free all associated resources.
`abstract void`	`flush()` Flush any buffered output.
`String`	`getEncoding()` Return the character encoding for this `Handler`.
`ErrorManager`	`getErrorManager()` Retrieves the ErrorManager for this Handler.
`Filter`	`getFilter()` Get the current `Filter` for this `Handler`.
`Formatter`	`getFormatter()` Return the `Formatter` for this `Handler`.
`Level`	`getLevel()` Get the log level specifying which messages will be logged by this `Handler`.
`boolean`	`isLoggable(LogRecord record)` Check if this `Handler` would actually log a given `LogRecord`.
`abstract void`	`publish(LogRecord record)` Publish a `LogRecord`.
`void`	`setEncoding(String encoding)` Set the character encoding used by this `Handler`.
`void`	`setErrorManager(ErrorManager em)` Define an ErrorManager for this Handler.
`void`	`setFilter(Filter newFilter)` Set a `Filter` to control output on this `Handler`.
`void`	`setFormatter(Formatter newFormatter)` Set a `Formatter`.
`void`	`setLevel(Level newLevel)` Set the log level specifying which message levels will be logged by this `Handler`.

Protected methods
`void`	`reportError(String msg, Exception ex, int code)` Protected convenience method to report an error to this Handler's ErrorManager.

Inherited methods

From class


        
          java.lang.Object

`Object`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>`	`getClass()` Returns the runtime class of this `Object`.
`int`	`hashCode()` Returns a hash code value for the object.
`final void`	`notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void`	`notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String`	`toString()` Returns a string representation of the object.
`final void`	`wait(long timeoutMillis, int nanos)` Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`	`wait(long timeoutMillis)` Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`	`wait()` Causes the current thread to wait until it is awakened, typically by being notified or interrupted.

Protected constructors

Handler

Added in API level 1

protected Handler ()

Default constructor. The resulting Handler has a log level of Level.ALL, no Formatter, and no Filter. A default ErrorManager instance is installed as the ErrorManager.

Public methods

close

Added in API level 1

public abstract void close ()

Close the Handler and free all associated resources.

The close method will perform a flush and then close the Handler. After close has been called this Handler should no longer be used. Method calls may either be silently ignored or may throw runtime exceptions.

Throws
`SecurityException`	if a security manager exists and if the caller does not have `LoggingPermission("control")`.

flush

Added in API level 1

public abstract void flush ()

Flush any buffered output.

getEncoding

Added in API level 1

public String getEncoding ()

Return the character encoding for this Handler.

Returns
`String`	The encoding name. May be null, which indicates the default encoding should be used.

getErrorManager

Added in API level 1

public ErrorManager getErrorManager ()

Retrieves the ErrorManager for this Handler.

Returns
`ErrorManager`	the ErrorManager for this Handler

Throws
`SecurityException`	if a security manager exists and if the caller does not have `LoggingPermission("control")`.

getFilter

Added in API level 1

public Filter getFilter ()

Get the current Filter for this Handler.

Returns
`Filter`	a `Filter` object (may be null)

getFormatter

Added in API level 1

public Formatter getFormatter ()

Return the Formatter for this Handler.

Returns
`Formatter`	the `Formatter` (may be null).

getLevel

Added in API level 1

public Level getLevel ()

Get the log level specifying which messages will be logged by this Handler. Message levels lower than this level will be discarded.

Returns
`Level`	the level of messages being logged.

isLoggable

Added in API level 1

public boolean isLoggable (LogRecord record)

Check if this Handler would actually log a given LogRecord.

This method checks if the LogRecord has an appropriate Level and whether it satisfies any Filter. It also may make other Handler specific checks that might prevent a handler from logging the LogRecord. It will return false if the LogRecord is null.

Parameters
`record`	`LogRecord`: a `LogRecord`

Returns
`boolean`	true if the `LogRecord` would be logged.

publish

Added in API level 1

public abstract void publish (LogRecord record)

Publish a LogRecord.

The logging request was made initially to a Logger object, which initialized the LogRecord and forwarded it here.

The Handler is responsible for formatting the message, when and if necessary. The formatting should include localization.

Parameters
`record`	`LogRecord`: description of the log event. A null record is silently ignored and is not published

setEncoding

Added in API level 1

public void setEncoding (String encoding)

Set the character encoding used by this Handler.

The encoding should be set before any LogRecords are written to the Handler.

Parameters
`encoding`	`String`: The name of a supported character encoding. May be null, to indicate the default platform encoding.

Throws
`SecurityException`	if a security manager exists and if the caller does not have `LoggingPermission("control")`.
`UnsupportedEncodingException`	if the named encoding is not supported.

setErrorManager

Added in API level 1

public void setErrorManager (ErrorManager em)

Define an ErrorManager for this Handler.

The ErrorManager's "error" method will be invoked if any errors occur while using this Handler.

Parameters
`em`	`ErrorManager`: the new ErrorManager

Throws
`SecurityException`	if a security manager exists and if the caller does not have `LoggingPermission("control")`.

setFilter

Added in API level 1

public void setFilter (Filter newFilter)

Set a Filter to control output on this Handler.

For each call of publish the Handler will call this Filter (if it is non-null) to check if the LogRecord should be published or discarded.

Parameters
`newFilter`	`Filter`: a `Filter` object (may be null)

Throws
`SecurityException`	if a security manager exists and if the caller does not have `LoggingPermission("control")`.

setFormatter

Added in API level 1

public void setFormatter (Formatter newFormatter)

Set a Formatter. This Formatter will be used to format LogRecords for this Handler.

Some Handlers may not use Formatters, in which case the Formatter will be remembered, but not used.

Parameters
`newFormatter`	`Formatter`: the `Formatter` to use (may not be null)

Throws
`SecurityException`	if a security manager exists and if the caller does not have `LoggingPermission("control")`.

setLevel

Added in API level 1

public void setLevel (Level newLevel)

Set the log level specifying which message levels will be logged by this Handler. Message levels lower than this value will be discarded.

The intention is to allow developers to turn on voluminous logging, but to limit the messages that are sent to certain Handlers.

Parameters
`newLevel`	`Level`: the new value for the log level

Throws
`SecurityException`	if a security manager exists and if the caller does not have `LoggingPermission("control")`.

Protected methods

reportError

Added in API level 1

protected void reportError (String msg, 
                Exception ex, 
                int code)

Protected convenience method to report an error to this Handler's ErrorManager. Note that this method retrieves and uses the ErrorManager without doing a security check. It can therefore be used in environments where the caller may be non-privileged.

Parameters
`msg`	`String`: a descriptive string (may be null)
`ex`	`Exception`: an exception (may be null)
`code`	`int`: an error code defined in ErrorManager