sample/java.util.logging.Handler.txt

   1 *java.util.logging.Handler* *Handler* A Handler object takes log messages from a
   2
   3 public abstract class Handler
   4   extends    |java.lang.Object|
   5
   6 |java.util.logging.Handler_Description|
   7 |java.util.logging.Handler_Fields|
   8 |java.util.logging.Handler_Constructors|
   9 |java.util.logging.Handler_Methods|
  10
  11 ================================================================================
  12
  13 *java.util.logging.Handler_Constructors*
  14 |java.util.logging.Handler()|Default constructor.
  15
  16 *java.util.logging.Handler_Methods*
  17 |java.util.logging.Handler.close()|Close the Handler and free all associated re
  18 |java.util.logging.Handler.flush()|Flush any buffered output.
  19 |java.util.logging.Handler.getEncoding()|Return the character encoding for this
  20 |java.util.logging.Handler.getErrorManager()|Retrieves the ErrorManager for thi
  21 |java.util.logging.Handler.getFilter()|Get the current Filter for this Handler.
  22 |java.util.logging.Handler.getFormatter()|Return the Formatter for this Handler
  23 |java.util.logging.Handler.getLevel()|Get the log level specifying which messag
  24 |java.util.logging.Handler.isLoggable(LogRecord)|Check if this Handler would ac
  25 |java.util.logging.Handler.publish(LogRecord)|Publish a LogRecord.
  26 |java.util.logging.Handler.reportError(String,Exception,int)|Protected convenie
  27 |java.util.logging.Handler.setEncoding(String)|Set the character encoding used
  28 |java.util.logging.Handler.setErrorManager(ErrorManager)|Define an ErrorManager
  29 |java.util.logging.Handler.setFilter(Filter)|Set a Filter to control output on
  30 |java.util.logging.Handler.setFormatter(Formatter)|Set a Formatter.
  31 |java.util.logging.Handler.setLevel(Level)|Set the log level specifying which m
  32
  33 *java.util.logging.Handler_Description*
  34
  35 A Handler object takes log messages from a Logger and exports them. It might
  36 for example, write them to a console or write them to a file, or send them to a
  37 network logging service, or forward them to an OS log, or whatever.
  38
  39 A Handler can be disabled by doing a setLevel(Level.OFF) and can be re-enabled
  40 by doing a setLevel with an appropriate level.
  41
  42 Handler classes typically use LogManager properties to set default values for
  43 the Handler's Filter, Formatter, and Level. See the specific documentation for
  44 each concrete Handler class.
  45
  46
  47
  48 *java.util.logging.Handler()*
  49
  50 protected Handler()
  51
  52 Default constructor. The resulting Handler has a log level of Level.ALL, no
  53 Formatter, and no Filter. A default ErrorManager instance is installed as the
  54 ErrorManager.
  55
  56
  57 *java.util.logging.Handler.close()*
  58
  59 public abstract void close()
  60   throws |java.lang.SecurityException|
  61
  62 Close the Handler and free all associated resources.
  63
  64 The close method will perform a flush and then close the Handler. After close
  65 has been called this Handler should no longer be used. Method calls may either
  66 be silently ignored or may throw runtime exceptions.
  67
  68
  69
  70 *java.util.logging.Handler.flush()*
  71
  72 public abstract void flush()
  73
  74 Flush any buffered output.
  75
  76
  77
  78 *java.util.logging.Handler.getEncoding()*
  79
  80 public |java.lang.String| getEncoding()
  81
  82 Return the character encoding for this Handler.
  83
  84
  85
  86     Returns: The encoding name. May be null, which indicates the default encoding should be
  87              used.
  88
  89 *java.util.logging.Handler.getErrorManager()*
  90
  91 public |java.util.logging.ErrorManager| getErrorManager()
  92
  93 Retrieves the ErrorManager for this Handler.
  94
  95
  96
  97 *java.util.logging.Handler.getFilter()*
  98
  99 public |java.util.logging.Filter| getFilter()
 100
 101 Get the current Filter for this Handler.
 102
 103
 104
 105     Returns: a Filter object (may be null)
 106
 107 *java.util.logging.Handler.getFormatter()*
 108
 109 public |java.util.logging.Formatter| getFormatter()
 110
 111 Return the Formatter for this Handler.
 112
 113
 114
 115     Returns: the Formatter (may be null).
 116
 117 *java.util.logging.Handler.getLevel()*
 118
 119 public synchronized |java.util.logging.Level| getLevel()
 120
 121 Get the log level specifying which messages will be logged by this Handler.
 122 Message levels lower than this level will be discarded.
 123
 124
 125
 126     Returns: the level of messages being logged.
 127
 128 *java.util.logging.Handler.isLoggable(LogRecord)*
 129
 130 public boolean isLoggable(java.util.logging.LogRecord record)
 131
 132 Check if this Handler would actually log a given LogRecord.
 133
 134 This method checks if the LogRecord has an appropriate Level and whether it
 135 satisfies any Filter. It also may make other Handler specific checks that might
 136 prevent a handler from logging the LogRecord. It will return false if the
 137 LogRecord is Null.
 138
 139
 140     record - a LogRecord
 141
 142     Returns: true if the LogRecord would be logged.
 143
 144 *java.util.logging.Handler.publish(LogRecord)*
 145
 146 public abstract void publish(java.util.logging.LogRecord record)
 147
 148 Publish a LogRecord.
 149
 150 The logging request was made initially to a Logger object, which initialized
 151 the LogRecord and forwarded it here.
 152
 153 The Handler is responsible for formatting the message, when and if necessary.
 154 The formatting should include localization.
 155
 156
 157     record - description of the log event. A null record is silently ignored and is not
 158        published
 159
 160 *java.util.logging.Handler.reportError(String,Exception,int)*
 161
 162 protected void reportError(
 163   java.lang.String msg,
 164   java.lang.Exception ex,
 165   int code)
 166
 167 Protected convenience method to report an error to this Handler's ErrorManager.
 168 Note that this method retrieves and uses the ErrorManager without doing a
 169 security check. It can therefore be used in environments where the caller may
 170 be non-privileged.
 171
 172
 173     msg - a descriptive string (may be null)
 174     ex - an exception (may be null)
 175     code - an error code defined in ErrorManager
 176
 177 *java.util.logging.Handler.setEncoding(String)*
 178
 179 public void setEncoding(java.lang.String encoding)
 180   throws |java.lang.SecurityException|
 181          |java.io.UnsupportedEncodingException|
 182
 183 Set the character encoding used by this Handler.
 184
 185 The encoding should be set before any LogRecords are written to the Handler.
 186
 187
 188     encoding - The name of a supported character encoding. May be null, to indicate the
 189        default platform encoding.
 190
 191 *java.util.logging.Handler.setErrorManager(ErrorManager)*
 192
 193 public void setErrorManager(java.util.logging.ErrorManager em)
 194
 195 Define an ErrorManager for this Handler.
 196
 197 The ErrorManager's "error" method will be invoked if any errors occur while
 198 using this Handler.
 199
 200
 201     em - the new ErrorManager
 202
 203 *java.util.logging.Handler.setFilter(Filter)*
 204
 205 public void setFilter(java.util.logging.Filter newFilter)
 206   throws |java.lang.SecurityException|
 207
 208 Set a Filter to control output on this Handler.
 209
 210 For each call of publish the Handler will call this Filter (if it is non-null)
 211 to check if the LogRecord should be published or discarded.
 212
 213
 214     newFilter - a Filter object (may be null)
 215
 216 *java.util.logging.Handler.setFormatter(Formatter)*
 217
 218 public void setFormatter(java.util.logging.Formatter newFormatter)
 219   throws |java.lang.SecurityException|
 220
 221 Set a Formatter. This Formatter will be used to format LogRecords for this
 222 Handler.
 223
 224 Some Handlers may not use Formatters, in which case the Formatter will be
 225 remembered, but not used.
 226
 227
 228     newFormatter - the Formatter to use (may not be null)
 229
 230 *java.util.logging.Handler.setLevel(Level)*
 231
 232 public synchronized void setLevel(java.util.logging.Level newLevel)
 233   throws |java.lang.SecurityException|
 234
 235 Set the log level specifying which message levels will be logged by this
 236 Handler. Message levels lower than this value will be discarded.
 237
 238 The intention is to allow developers to turn on voluminous logging, but to
 239 limit the messages that are sent to certain Handlers.
 240
 241
 242     newLevel - the new value for the log level
 243
 244