Specify handler for a logger in properties file

Question

Hello All,
Is there a way of specifying a specific handler for a specific logger within the logging.properties file? I have not been able to find any documentation on the logging.properties file settings. I am looking for something like this:
com.eric.program.handlers = java.util.logging.ConsoleHandler
com.frank.handlers = java.util.logging.FileHandler
I would rather keep all my settings within this properties file instead of coding it. If you know where I can find some documentation, please let me know. I am using J2SE 1.4.1.
Thanks.

Answer 1

Well, after failing to assign a handler to a specific logger, I checked the LogManager source code and, alas, it only supports assigning handlers to the root logger.
What a bummer ... I think this is a real flaw in the LogManager design, especially since log4j supports assigning appenders to specific logger.
The (more or less) good news is that LogManager is designed for subclassing (by j2ee container apps, but hey) ... so you can try to add this functionality to your own LogManager and use that through the system property java.util.logging.manager.
import java.io.*;
import java.security.*;
import java.util.*;
import java.util.logging.*;
* All properties whose names end with ".handlers" are assumed to define a
* whitespace separated list of class names for handler classes to load and
* register as handlers on the logger (whose name corresponds to the property
* prefix). Each class name must be for a Handler class which has a default
* constructor.
public class CustomLogManager extends LogManager
    public CustomLogManager()
        super();
     * Overwritten to also add handlers
    public synchronized boolean addLogger(Logger logger)
        final boolean res = super.addLogger(logger);
        final String property = logger.getName() + ".handlers";
        if ( null != getProperty(property) )
            setHandlers(logger, property);
        return res;
    // Taken from java/util/logging/LogManager.java#initializeGlobalHandlers()
    private void setHandlers(final Logger logger, final String property)
        // We need to raise privilege here.  All our decisions will
        // be made based on the logging configuration, which can
        // only be modified by trusted code.
        AccessController.doPrivileged(new PrivilegedAction() {
            public Object run() {
                // Add new global handlers.
                String names[] = parseClassNames(property);
                for (int i = 0; i < names.length; i++) {
                    String word = names;
try {
Class clz = ClassLoader.getSystemClassLoader().loadClass(word);
Handler h = (Handler) clz.newInstance();
try {
// Check if there is a property defining the
// handler's level.
String levs = getProperty(word + ".level");
if (levs != null) {
h.setLevel(Level.parse(levs));
} catch (Exception ex) {
System.err.println("Can't set level for " + word);
// Probably a bad level. Drop through.
logger.addHandler(h);
} catch (Exception ex) {
System.err.println("Can't load log handler \"" + word + "\"");
System.err.println("" + ex);
ex.printStackTrace();
return null;
// Taken from java/util/logging/LogManager.java
// get a list of whitespace separated classnames from a property.
private String[] parseClassNames(String propertyName) {
String hands = getProperty(propertyName);
if (hands == null) {
return new String[0];
hands = hands.trim();
int ix = 0;
Vector result = new Vector();
while (ix < hands.length()) {
int end = ix;
while (end < hands.length()) {
if (Character.isWhitespace(hands.charAt(end))) {
break;
if (hands.charAt(end) == ',') {
break;
end++;
String word = hands.substring(ix, end);
ix = end+1;
word = word.trim();
if (word.length() == 0) {
continue;
result.add(word);
return (String[]) result.toArray(new String[result.size()]);
On the other hand, it might be possible to write a reusable config class which does that kind of initialization, too.