Question

What type of process would I need in a new class to ‘read’ all of the colors that are in this class below? I use the class to set colors on components and love it. But the time has come to allow my application to right-click on a panel and change the background color for example.

What would get me started in the correct direction code-wise in continuing to use these colors: ColorFactory.java

I was just starting to think about adding a new method to the class something like:

public Map<String, Color> getColorMapValues(){

    return colorMap;
    //
}

Answer 1

Since you have control over the source code in this case, it would be better to refactor the class to meet your needs than using reflection (which is not only expensive, but is prohibited depending on your security policy).

The technique commonly used is the Holder pattern. See Joshua Bloch’s Effective Java (2nd Edition) Item 71 for more information. We can also avoid synchronization on reads by using a thread-safe, non blocking structure, namely java.util.concurrent.ConcurrentHashMap.

public class ColorFactory {
    private static class ColorFactoryHolder {
        // creates on instantiation of ColorFactoryHolder
        // synchronization is baked into the JVM, but won't be created until
        // the class is used, see JLS 12.4.1
        static final ColorFactory instance = new ColorMap();
    }
    public static ColorFactory getInstance() { return ColorFactoryHolder.instance; }
    // concurrent hash map - all operations are thread safe
    Map<String,Color> colormap = new ConcurrentHashMap<String,Color>();
    private final Object lock = new Object();
    private ColorFactory() {
        colormap.add("blue",new Color(0,0,255));
        // rest of colors here
    }
    public Color getColor(String spec) {
        if(colormap.containsKey(spec)) return colormap.get(spec);
        // don't synchronize externally - Bloch et al, item 70
        synchronized(lock) { 
            // double check idiom - not broken, as map is thread safe
            if(colormap.containsKey(spec)) return colormap.get(spec);
            Color color = parse(spec); // parse method can be extracted from old code
            colormap.put(spec,color);
            return color;
        }
    }
    private static Color parse(String spec) {
        // parse the color spec here
    }    
}

In fact, because the parse operation is likely to be very, very fast (in comparison to the synchronization), we can do away with the synchronization altogether. So we might end up parsing the value multiple times – not really a big problem, since the result will be the same every time. See Bloch et al. Item 69 for more information.

public class ColorFactory {
    private static class ColorFactoryHolder {
        // same as above, snipped for brevity
    }
    public static ColorFactory getInstance() { return ColorFactoryHolder.instance; }
    // requires ConcurrentMap reference to get putIfAbsent(K,V) method
    ConcurrentMap<String,Color> colormap = new ConcurrentHashMap<String,Color>();
    // private final Object lock = new Object(); - removed
    private ColorFactory() {
        colormap.add("blue",new Color(0,0,255));
        // rest of colors here
    }
    public Color getColor(String spec) {
        Color result = colormap.get(spec);
        if(result == null) {         
            result = parse(spec); // may parse multiple times, but still
                                  // cheaper than synchronization
            colormap.putIfAbsent(spec,result);            
        }
        return result
    }
    private static Color parse(String spec) {
        // parse the color spec here
    }    
}