| java.lang.Object
 java.util.logging.Handler
java.util.logging.MemoryHandler
| MemoryHandler | | public class MemoryHandler extends Handler (Code) | | MemoryHandler is a Handler that 'remembers' a
finite number of LogRecords at a time and stores them in a
buffer without formatting them. When the buffer is full this
Handler overwrites the oldest record as each new record is
added.
Every MemoryHandler has a target Handler, and
calling the push() method on the MemoryHandler
will output all buffered records to the target Handler After
the push action, the buffer will be cleared.
The push method can be called directly, but will also be called automatically
if a new LogRecord is added that has a level greater than or
equal to than the value defined for the property
java.util.logging.MemoryHandler.push.
MemoryHandler defines the following configuration properties,
which are read by the LogManager on initialization. If the
properties have not been specified then defaults will be used. The properties
and defaults are as follows:
- java.util.logging.MemoryHandler.filter - the
Filter class
name. No Filter is used by default.
- java.util.logging.MemoryHandler.level - the log level for this
Handler. Default is Level.ALL.
- java.util.logging.MemoryHandler.push - the push level. Default is
Level.SEVERE.
- java.util.logging.MemoryHandler.size - the buffer size in number of
LogRecords. Default is 1000.
- java.util.logging.MemoryHandler.target - the class name of the target
Handler. No default value, which means this property must be
specified either by property setting or by constructor.
|
| Method Summary | |
| public void | close()
| | public void | flush()
Call target handler to flush any buffered output. | | public Level | getPushLevel()
Return the push level. | | public boolean | isLoggable(LogRecord record)
Check if given LogRecord would be put into this
MemoryHandler's internal buffer. | | public synchronized void | publish(LogRecord record)
Put a given LogRecord into internal buffer.
If given record is not loggable, just return. | | public void | push()
Triggers a push action to output all buffered records to the target
handler, and the target handler will publish them. | | public void | setPushLevel(Level newLevel)
Set the push level. |
| MemoryHandler | | public MemoryHandler()(Code) | | Default constructor, construct and init a MemoryHandler
using LogManager properties or default values
|
| MemoryHandler | | public MemoryHandler(Handler target, int size, Level pushLevel)(Code) | | Construct and init a MemoryHandler using given target,
size and push level, other properties using LogManager
properties or default values
Parameters:
target - the given Handler to output
Parameters:
size - the maximum number of buffered LogRecord
Parameters:
pushLevel - the push level
throws:
IllegalArgumentException - if size<=0 |
| close | | public void close()(Code) | | Close this handler and target handler, free all associated resources
throws:
SecurityException - if security manager exists and it determines that caller doesnot have the required permissions to control this handler |
| flush | | public void flush()(Code) | | Call target handler to flush any buffered output.
Note that this doesn't cause this MemoryHandler to push.
|
| getPushLevel | | public Level getPushLevel()(Code) | | Return the push level.
the push level |
| isLoggable | | public boolean isLoggable(LogRecord record)(Code) | | Check if given LogRecord would be put into this
MemoryHandler's internal buffer.
The given LogRecord is loggable if and only if it has
appropriate level and it pass any associated filter's check.
Note that the push level is not used for this check.
Parameters:
record - the given LogRecord if the given LogRecord should be logged |
| publish | | public synchronized void publish(LogRecord record)(Code) | | Put a given LogRecord into internal buffer.
If given record is not loggable, just return. Otherwise it is stored in
the buffer. Furthermore if the record's level is not less than the push
level, the push action is triggered to output all the buffered records to
the target handler, and the target handler will publish them.
Parameters:
record - the log record. |
| push | | public void push()(Code) | | Triggers a push action to output all buffered records to the target
handler, and the target handler will publish them. Then the buffer is
cleared.
|
| setPushLevel | | public void setPushLevel(Level newLevel)(Code) | | Set the push level. The push level is used to check the push action
triggering. When a new LogRecord is put into the internal
buffer and its level is not less than the push level, the push action
will be triggered. Note that set new push level won't trigger push
action.
Parameters:
newLevel - the new level to set
throws:
SecurityException - if security manager exists and it determines that caller doesnot have the required permissions to control this handler |
|
|