Development Class Java

  1. Home
  2. Java
  3. Development Class
  4. A java util Properties class that will check a file or URL for changes periodically
/*
 * RefreshingProperties.java
 *
 * Created on November 11, 2005, 10:15 PM
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 * This is a java.util.Properties class that will check a file or URL for changes
 * periodically. It has a threaded and non-threaded mode, and will reload a URL
 * every recheck time, or inspect the last modified date on a file on check.
 * @author Robert "kebernet" Cooper
 * @version $Revision: 1.4 $
 */
public class RefreshingProperties extends Properties {
    /**
     * DOCUMENT ME!
     */
    private static final Logger LOG = Logger.getLogger( RefreshingProperties.class.getCanonicalName() );
    
    
    /**
     * DOCUMENT ME!
     */
    private ArrayList listeners = new ArrayList();
    
    /**
     * DOCUMENT ME!
     */
    private Thread updater;
    
    /**
     * DOCUMENT ME!
     */
    private URL url;
    
    /**
     * DOCUMENT ME!
     */
    private long lastCheck;
    
    /**
     * DOCUMENT ME!
     */
    private long recheckTime = 5 * 60 * 1000;
    
    private boolean loading = false;
    
    private ArrayList augmentProps = new ArrayList();
    private ArrayList overrideProps = new ArrayList();
    
    private boolean noImportMode = false;
    
    /**
     * Creates a new RefreshingProperties object.
     * This constructor will use the default settings of threaded mode and recheck at 5 minutes.
     * @param url URL to read from.
     * @throws IOException Thrown on read errors.
     */
    public RefreshingProperties(URL url) throws IOException {
        init(url,recheckTime,true);
    }
    
    /**
     * Creates a new RefreshingProperties object.
     * This will use the default recheck at 5 minutes.
     * @param url URL to read from
     * @param useThread Indicates whether the check should run in threaded or non-threaded road.
     * @throws IOException Thrown on read errors.
     */
    public RefreshingProperties(URL url,boolean useThread) throws IOException {
        init(url,recheckTime,useThread);
    }
    
    /**
     * Creates a new RefreshingProperties object.
     * Uses the default threaded mode.
     * @param recheckTime number of milliseconds between rechecks
     * @param url URL to load from
     * @throws IOException Thrown on read errors.
     */
    public RefreshingProperties(URL url,long recheckTime) throws IOException {
        init(url,recheckTime,true);
    }
    
    /**
     * Creates a new RefreshingProperties object.
     * @param url URL to read from
     * @param recheckTime recheck time in milliseconds
     * @param useThread Whether the recheck should be threaded or unthreaded.
     * @throws IOException Thrown on read errors.
     */
    public RefreshingProperties(URL url,long recheckTime,boolean useThread) throws IOException {
        init(url,recheckTime,useThread);
    }
    
    /**
     * Calls the Hashtable method put. Provided for
     * parallelism with the getProperty method. Enforces use of
     * strings for property keys and values. The value returned is the
     * result of the Hashtable call to put.
     *
     * @param key the key to be placed into this property list.
     * @param value the value corresponding to key.
     * @return     the previous value of the specified key in this property
     *             list, or null if it did not have one.
     * @see #getProperty
     * @since    1.2
     */
    public Object setProperty(String key,String value) {
        Object retValue;
        threadCheck();
        retValue = super.setProperty(key,value);
        
        return retValue;
    }
    
    /**
     * Searches for the property with the specified key in this property list.
     * If the key is not found in this property list, the default property list,
     * and its defaults, recursively, are then checked. The method returns
     * null if the property is not found.
     *
     * @param   key   the property key.
     * @return  the value in this property list with the specified key value.
     * @see     #setProperty
     * @see     #defaults
     */
    public String getProperty(String key) {
        threadCheck();
        
        String retValue;
        retValue = super.getProperty(key);
        
        return retValue;
    }
    
    /**
     * Searches for the property with the specified key in this property list.
     * If the key is not found in this property list, the default property list,
     * and its defaults, recursively, are then checked. The method returns the
     * default value argument if the property is not found.
     *
     * @param   key            the hashtable key.
     * @param   defaultValue   a default value.
     *
     * @return  the value in this property list with the specified key value.
     * @see     #setProperty
     * @see     #defaults
     */
    public String getProperty(String key,String defaultValue) {
        String retValue;
        threadCheck();
        retValue = super.getProperty(key,defaultValue);
        
        return retValue;
    }
    
    /**
     * DOCUMENT ME!
     *
     * @param listener DOCUMENT ME!
     */
    public void addRefreshListener(RefreshingProperties.RefreshListener listener) {
        this.listeners.add(listener);
    }
    
    /**
     * Creates a shallow copy of this hashtable. All the structure of the
     * hashtable itself is copied, but the keys and values are not cloned.
     * This is a relatively expensive operation.
     *
     * @return  a clone of the hashtable.
     */
    public Object clone() {
        Object retValue;
        threadCheck();
        retValue = super.clone();
        
        return retValue;
    }
    
    /**
     * Tests if some key maps into the specified value in this hashtable.
     * This operation is more expensive than the containsKey
     * method.


     *
     * Note that this method is identical in functionality to containsValue,
     * (which is part of the Map interface in the collections framework).
     *
     * @return true if and only if some key maps to the
     *             value argument in this hashtable as
     *             determined by the equals method;
     *             false otherwise.
     * @see #containsKey(Object)
     * @see #containsValue(Object)
     * @see Map
     * @param value a value to search for.
     */
    public boolean contains(Object value) {
        threadCheck();
        
        boolean retValue;
        
        retValue = super.contains(value);
        
        return retValue;
    }
    
    /**
     * Tests if the specified object is a key in this hashtable.
     *
     * @return true if and only if the specified object
     *          is a key in this hashtable, as determined by the
     *          equals method; false otherwise.
     * @see #contains(Object)
     * @param key possible key.
     */
    public boolean containsKey(Object key) {
        boolean retValue;
        threadCheck();
        retValue = super.containsKey(key);
        
        return retValue;
    }
    
    /**
     * Returns true if this Hashtable maps one or more keys to this value.


     *
     * Note that this method is identical in functionality to contains
     * (which predates the Map interface).
     *
     * @return true if this map maps one or more keys to the
     *         specified value.
     * @see Map
     * @since 1.2
     * @param value value whose presence in this Hashtable is to be tested.
     */
    public boolean containsValue(Object value) {
        boolean retValue;
        threadCheck();
        retValue = super.containsValue(value);
        
        return retValue;
    }
    
    /**
     * Returns an enumeration of the values in this hashtable.
     * Use the Enumeration methods on the returned object to fetch the elements
     * sequentially.
     *
     * @return  an enumeration of the values in this hashtable.
     * @see     java.util.Enumeration
     * @see     #keys()
     * @see        #values()
     * @see        Map
     */
    public java.util.Enumeration elements() {
        java.util.Enumeration retValue;
        threadCheck();
        retValue = super.elements();
        
        return retValue;
    }
    
    /**
     * Returns a Set view of the entries contained in this Hashtable.
     * Each element in this collection is a Map.Entry.  The Set is
     * backed by the Hashtable, so changes to the Hashtable are reflected in
     * the Set, and vice-versa.  The Set supports element removal
     * (which removes the corresponding entry from the Hashtable),
     * but not element addition.
     *
     * @return a set view of the mappings contained in this map.
     * @see   Map.Entry
     * @since 1.2
     */
    public java.util.Set> entrySet() {
        java.util.Set retValue;
        threadCheck();
        retValue = super.entrySet();
        
        return retValue;
    }
    
    /**
     * Returns the value to which the specified key is mapped in this hashtable.
     *
     * @return the value to which the key is mapped in this hashtable;
     *          null if the key is not mapped to any value in
     *          this hashtable.
     * @see #put(Object, Object)
     * @param key a key in the hashtable.
     */
    public Object get(Object key) {
        threadCheck();
        
        Object retValue;
        for( RefreshingProperties over : this.overrideProps ){
            Object overValue = over.get(key);
            if( overValue != null){
                return overValue;
            }
        }
        retValue = super.get(key);
        if( retValue == null ){
            for( RefreshingProperties aug : this.augmentProps ){
                Object augValue = aug.get( key );
                if( augValue != null ){
                    retValue = augValue;
                    break;
                }
            }
        }
        return retValue;
    }
    
    /**
     * Returns a Set view of the keys contained in this Hashtable.  The Set
     * is backed by the Hashtable, so changes to the Hashtable are reflected
     * in the Set, and vice-versa.  The Set supports element removal
     * (which removes the corresponding entry from the Hashtable), but not
     * element addition.
     *
     * @return a set view of the keys contained in this map.
     * @since 1.2
     */
    public java.util.Set keySet() {
        java.util.Set retValue;
        threadCheck();
        retValue = super.keySet();
        for( RefreshingProperties props : this.augmentProps ){
            retValue.addAll( props.keySet() );
        }
        for( RefreshingProperties props : this.overrideProps ){
            retValue.addAll( props.keySet() );
        }
        return retValue;
    }
    
    /**
     * Returns an enumeration of the keys in this hashtable.
     *
     * @return  an enumeration of the keys in this hashtable.
     * @see     Enumeration
     * @see     #elements()
     * @see        #keySet()
     * @see        Map
     */
    public java.util.Enumeration keys() {
        java.util.Enumeration retValue;
        threadCheck();
        retValue = (new Vector( this.keySet() )).elements();        
        return retValue;
    }
    
    /**
     * Returns an enumeration of all the keys in this property list,
     * including distinct keys in the default property list if a key
     * of the same name has not already been found from the main
     * properties list.
     *
     * @return  an enumeration of all the keys in this property list, including
     *          the keys in the default property list.
     * @see     java.util.Enumeration
     * @see     java.util.Properties#defaults
     */
    public java.util.Enumeration propertyNames() {
        java.util.Enumeration retValue;
        threadCheck();
        retValue = super.propertyNames();
        
        return retValue;
    }
    
    /**
     * Maps the specified key to the specified
     * value in this hashtable. Neither the key nor the
     * value can be null. 


     *
     * The value can be retrieved by calling the get method
     * with a key that is equal to the original key.
     *
     * @return the previous value of the specified key in this hashtable,
     *             or null if it did not have one.
     * @see Object#equals(Object)
     * @see #get(Object)
     * @param key the hashtable key.
     * @param value the value.
     */
    public Object put(Object key,Object value) {
        threadCheck();
        if( !this.noImportMode && key instanceof String && ((String) key ).startsWith("@import.") ){
            String keyString = ((String) key );
            String importType = keyString.substring( 8, keyString.lastIndexOf(".") );
            ImportRefreshListener irl = null;
            
            if( importType.equals("override") ){
                irl = new ImportRefreshListener( this, true );
            } else if( importType.equals("augment") ) {
                irl = new ImportRefreshListener( this, false );
            } else {
                throw new RuntimeException("Import type: "+importType+" unknown.");
            }
            try{
                boolean useThread = (this.updater != null );
                RefreshingProperties importedProp = new RefreshingProperties( new URL( this.url, (String) value ), this.recheckTime, useThread );
                if( irl.clobber ){
                    this.overrideProps.add( importedProp );
                } else {
                    this.augmentProps.add( importedProp );
                }
                importedProp.addRefreshListener( irl );
                this.importLoad( importedProp, irl.clobber );
            } catch(Exception e){
                throw new RuntimeException("Exception creaing child properties", e);
            }
        }
        return super.put(key,value);
    }
    
    /**
     * Copies all of the mappings from the specified Map to this Hashtable
     * These mappings will replace any mappings that this Hashtable had for any
     * of the keys currently in the specified Map.
     *
     * @since 1.2
     * @param t Mappings to be stored in this map.
     */
    public void putAll(java.util.Map t) {
        threadCheck();
        super.putAll(t);
    }
    
    /**
     * Removes the key (and its corresponding value) from this
     * hashtable. This method does nothing if the key is not in the hashtable.
     *
     * @return the value to which the key had been mapped in this hashtable,
     *          or null if the key did not have a mapping.
     * @param key the key that needs to be removed.
     */
    public Object remove(Object key) {
        threadCheck();
        
        Object retValue;
        
        retValue = super.remove(key);
        
        return retValue;
    }
    
    /**
     * DOCUMENT ME!
     *
     * @param listener DOCUMENT ME!
     */
    public void removeRefreshListener(RefreshingProperties.RefreshListener listener) {
        this.listeners.remove(listener);
    }
    
    /**
     * Returns a Collection view of the values contained in this Hashtable.
     * The Collection is backed by the Hashtable, so changes to the Hashtable
     * are reflected in the Collection, and vice-versa.  The Collection
     * supports element removal (which removes the corresponding entry from
     * the Hashtable), but not element addition.
     *
     * @return a collection view of the values contained in this map.
     * @since 1.2
     */
    public java.util.Collection values() {
        java.util.Collection retValue;
        threadCheck();
        ArrayList values = new ArrayList();
        for( Object key : this.keySet() ){
            values.add( this.get(key ) );
        }
        
        return values;
    }
    
    /**
     * DOCUMENT ME!
     */
    private void check() {
        try {
            if(this.url.getProtocol().equals("file") ) {
                File f = new File(this.url.getFile());
                if( f.lastModified() > this.lastCheck ){
                    this.load();
                }
            } else if( !this.url.getProtocol().equals("file") && System.currentTimeMillis() - this.lastCheck > this.recheckTime ){
                this.load();
            }
            this.lastCheck = System.currentTimeMillis();
        } catch(IOException e) {
            RefreshingProperties.LOG.log(Level.WARNING,"Exception reloading properies.",e);
        }
        
    }
    
    private void importLoad( RefreshingProperties source, boolean clobber ){
        Enumeration keys = source.keys();
        while( keys.hasMoreElements() ){
            String key = (String) keys.nextElement();
            if( clobber || this.getProperty( key ) == null )
                this.put( key, source.getProperty( key ) );
        }
        this.fireEvents();
        
    }
    
    
    /**
     * DOCUMENT ME!
     *
     * @param url DOCUMENT ME!
     * @param recheckTime DOCUMENT ME!
     * @param useThread DOCUMENT ME!
     *
     * @throws IOException DOCUMENT ME!
     */
    private void init(URL url,long recheckTime,boolean useThread) throws IOException {
        this.url = url;
        this.recheckTime = recheckTime;
        if(useThread) {
            this.updater = new UpdateThread(this);
            this.updater.start();
        }
        
        this.check();
    }
    
    /**
     * DOCUMENT ME!
     *
     * @throws IOException DOCUMENT ME!
     */
    private void load() throws IOException {
        this.loading = true;
        InputStream is = null;
        super.clear();
        is = this.url.openStream();
        super.load(is);
        is.close();
        RefreshingProperties.LOG.log(Level.FINEST,"Loading of " + this.url + " at " + new Date());
        
        this.fireEvents();
        
        this.loading = false;
    }
    
    private void fireEvents(){
        RefreshingProperties.ReloadEvent event = new ReloadEvent(this, this.url,System.currentTimeMillis());
        
        for(RefreshingProperties.RefreshListener listener : this.listeners) {
            listener.propertiesRefreshNotify(event);
        }
    }
    
    /**
     * DOCUMENT ME!
     */
    private void threadCheck() {
        if(!this.loading && this.updater == null) {
            check();
        }
    }
    
    /**
     * DOCUMENT ME!
     *
     * @author $author$
     * @version $Revision: 1.4 $
     */
    public static interface RefreshListener {
        /**
         * DOCUMENT ME!
         *
         * @param event DOCUMENT ME!
         */
        public void propertiesRefreshNotify(RefreshingProperties.ReloadEvent event);
    }
    
    /**
     * DOCUMENT ME!
     *
     * @author $author$
     * @version $Revision: 1.4 $
     */
    public static class ReloadEvent {
        /**
         * DOCUMENT ME!
         */
        private URL url;
        
        /**
         * DOCUMENT ME!
         */
        private long time;
        
        private RefreshingProperties source;
        /**
         * Creates a new ReloadEvent object.
         *
         * @param url DOCUMENT ME!
         * @param time DOCUMENT ME!
         */
        public ReloadEvent(RefreshingProperties source, URL url,long time) {
            this.setSource(source);
            this.url = url;
            this.time = time;
        }
        
        /**
         * DOCUMENT ME!
         *
         * @param time DOCUMENT ME!
         */
        public void setTime(long time) {
            this.time = time;
        }
        
        /**
         * DOCUMENT ME!
         *
         * @return DOCUMENT ME!
         */
        public long getTime() {
            return time;
        }
        
        /**
         * DOCUMENT ME!
         *
         * @param url DOCUMENT ME!
         */
        public void setUrl(URL url) {
            this.url = url;
        }
        
        /**
         * DOCUMENT ME!
         *
         * @return DOCUMENT ME!
         */
        public URL getUrl() {
            return url;
        }
        
        public RefreshingProperties getSource() {
            return source;
        }
        
        public void setSource(RefreshingProperties source) {
            this.source = source;
        }
    }
    
    /**
     * DOCUMENT ME!
     *
     * @author $author$
     * @version $Revision: 1.4 $
     */
    private class UpdateThread extends Thread {
        /**
         * DOCUMENT ME!
         */
        private RefreshingProperties props;
        
        /**
         * Creates a new UpdateThread object.
         *
         * @param props DOCUMENT ME!
         */
        UpdateThread(RefreshingProperties props) {
            this.setDaemon(true);
            this.props = props;
        }
        
        /**
         * DOCUMENT ME!
         */
        public void run() {
            boolean running = true;
            
            while(running) {
                props.LOG.log(Level.FINEST,"RefeshingProperties thread check of " + props.url + " at " + new Date());
                
                try {
                    Thread.sleep(props.recheckTime);
                } catch(InterruptedException e) {
                    RefreshingProperties.LOG.log(Level.WARNING,"Interrupted.",e);
                }
                
                props.check();
            }
        }
    }
    
    private class ImportRefreshListener implements RefreshListener {
        private RefreshingProperties target;
        private boolean clobber;
        ImportRefreshListener( RefreshingProperties target, boolean clobber ){
            this.target = target;
            this.clobber = clobber;
        }
        
        public void propertiesRefreshNotify(ReloadEvent event) {
            target.fireEvents();
        }
    }
}