Java example source code file (ConsoleHandler.java)

This example Java source code file (ConsoleHandler.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

consolehandler, exception, logmanager, override, simpleformatter, streamhandler, string

The ConsoleHandler.java Java example source code

/*
 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */


package java.util.logging;

/**
 * This <tt>Handler publishes log records to System.err.
 * By default the <tt>SimpleFormatter is used to generate brief summaries.
 * <p>
 * <b>Configuration:
 * By default each <tt>ConsoleHandler is initialized using the following
 * <tt>LogManager configuration properties where {@code }
 * refers to the fully-qualified class name of the handler.
 * If properties are not defined
 * (or have invalid values) then the specified default values are used.
 * <ul>
 * <li>   <handler-name>.level
 *        specifies the default level for the <tt>Handler
 *        (defaults to <tt>Level.INFO). 
 * <li>   <handler-name>.filter
 *        specifies the name of a <tt>Filter class to use
 *        (defaults to no <tt>Filter). 
 * <li>   <handler-name>.formatter
 *        specifies the name of a <tt>Formatter class to use
 *        (defaults to <tt>java.util.logging.SimpleFormatter). 
 * <li>   <handler-name>.encoding
 *        the name of the character set encoding to use (defaults to
 *        the default platform encoding). </li>
 * </ul>
 * <p>
 * For example, the properties for {@code ConsoleHandler} would be:
 * <ul>
 * <li>   java.util.logging.ConsoleHandler.level=INFO 
 * <li>   java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter 
 * </ul>
 * <p>
 * For a custom handler, e.g. com.foo.MyHandler, the properties would be:
 * <ul>
 * <li>   com.foo.MyHandler.level=INFO 
 * <li>   com.foo.MyHandler.formatter=java.util.logging.SimpleFormatter 
 * </ul>
 * <p>
 * @since 1.4
 */
public class ConsoleHandler extends StreamHandler {
    // Private method to configure a ConsoleHandler from LogManager
    // properties and/or default values as specified in the class
    // javadoc.
    private void configure() {
        LogManager manager = LogManager.getLogManager();
        String cname = getClass().getName();

        setLevel(manager.getLevelProperty(cname +".level", Level.INFO));
        setFilter(manager.getFilterProperty(cname +".filter", null));
        setFormatter(manager.getFormatterProperty(cname +".formatter", new SimpleFormatter()));
        try {
            setEncoding(manager.getStringProperty(cname +".encoding", null));
        } catch (Exception ex) {
            try {
                setEncoding(null);
            } catch (Exception ex2) {
                // doing a setEncoding with null should always work.
                // assert false;
            }
        }
    }

    /**
     * Create a <tt>ConsoleHandler for System.err.
     * <p>
     * The <tt>ConsoleHandler is configured based on
     * <tt>LogManager properties (or their default values).
     *
     */
    public ConsoleHandler() {
        sealed = false;
        configure();
        setOutputStream(System.err);
        sealed = true;
    }

    /**
     * Publish a <tt>LogRecord.
     * <p>
     * The logging request was made initially to a <tt>Logger object,
     * which initialized the <tt>LogRecord and forwarded it here.
     * <p>
     * @param  record  description of the log event. A null record is
     *                 silently ignored and is not published
     */
    @Override
    public void publish(LogRecord record) {
        super.publish(record);
        flush();
    }

    /**
     * Override <tt>StreamHandler.close to do a flush but not
     * to close the output stream.  That is, we do <b>not
     * close <tt>System.err.
     */
    @Override
    public void close() {
        flush();
    }
}