appl/data/LateLoadingProxy.java

package appl.data;

import java.io.File;
import java.io.Serializable;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

import appl.util.GeneralUtil;

/**
 * Loads an object on demand with the help of an <code>DataLoader</code>. The
 * unload() method unloads a serializable {@link Object} into a temporary folder
 * on the hard disk. Unloading can be disabled via the
 * {@link #setUnloading(boolean)} method.
 * 
 * @see DataLoader
 * @author Dominik Appl
 */
public class LateLoadingProxy implements DataProxy, Serializable {

        private File unloadFile;

        protected transient final Logger LOG = LogManager.getLogger(this.getClass()
                        .getName());

        /** Object loaded? */
        protected boolean loaded = false;

        protected transient DataLoader dataLoader;

        /**
         * The loader which constructs the object
         */
        protected transient DataLoader intialDataLoader;

        protected Object baseObject;

        private boolean unloadingEnabled;

        /**
         * Creates a new instance with the specified data loader
         * 
         * @param loader
         *            the load method of the {@link DataLoader} is called for
         *            loading
         */
        public LateLoadingProxy(DataLoader loader) {
                if (loader == null) {
                        throw new UnsupportedOperationException(
                                        "Error: the dataloader may not be null");
                }
                setUnloadDir("Temp");
                this.intialDataLoader = loader;
                this.dataLoader = loader;
        }

        private LateLoadingProxy() {
        };

        /**
         * returns the File, in which the object is/will be unloaded
         */
        protected File getUnloadFile() {
                return unloadFile;
        }

        /**
         * Loads the data into memory (if not already loaded).<br>
         * This method is thread-safe
         * 
         * @throws LoadingException
         */
        public synchronized void loadData() throws LoadingException {
                if (loaded)
                        return;
                try {
                        if (dataLoader == null)
                                throw new UnsupportedOperationException(
                                                "A dataloader was found to be null!");
                        baseObject = dataLoader.load();
                        if (LOG.isDebugEnabled())
                                LOG.debug("Successfully loaded " + baseObject + " with "
                                                + dataLoader.getLoadInfo());
                        loaded = true;

                } catch (LoadingException e) {
                        throw e;
                }
        }

        /***************************************************************************
         * If no Data is loaded or unloading is disabled this method does nothing,
         * else it saves the Data into a temporary File. <br>
         * Warning: Should be Thread-Safe with loadData, but was not tested
         **************************************************************************/
        public synchronized void unloadData() {
                // only do something if the Data is loaded and unloading is enabled:
                if (!loaded)
                        return;
                if (!unloadingEnabled)
                        return;
                // there is no way to save the Grid to a File, when its not serializible
                if (!(baseObject instanceof java.io.Serializable)) {
                        LOG.warn("Could not unload the Data because the class "
                                        + baseObject.getClass().getName() + "is not serializable");
                        return;
                }

                // unload the Data
                try {
                        GeneralUtil.SerializeToFile(baseObject, unloadFile);
                        loaded = false;
                        baseObject = null;
                        dataLoader = new SerializedDataLoader(unloadFile, true);
                        LOG.debug("Successfully unloaded Grid into File: "
                                        + unloadFile.getPath());
                } catch (Exception e) {
                        LOG.error("Error while trying to unload a grid into file '"
                                        + unloadFile.getAbsolutePath() + "'");
                        e.printStackTrace();
                }

        }

        /**
         * This class supports late loading, of course.
         * 
         * @see appl.data.LateLoadable#unloadData()
         * @return true;
         * @see appl.data.LateLoadable#isLateLoadable()
         */
        public boolean isLateLoadable() {
                return true;
        }

        /**
         * returns the baseObject
         * 
         * @see appl.data.DataProxy#getProxiedObject()
         */
        public Object getProxiedObject() {
                try {
                        loadData();
                } catch (LoadingException e) {
                        System.err.println("Error while loading Griddata ... ");
                        e.printStackTrace();
                }
                return baseObject;
        }

        /** returns true, if the baseObject is loaded */
        public boolean isLoaded() {
                return loaded;
        }

        public void setUnloadDir(String newUnloadDirectory) {
                unloadFile = new File(newUnloadDirectory + File.separatorChar
                                + this.toString() + ".tmp");
                // the unload file will be deleted after the JVM shuts down (only after
                // "normal" shutdown)
                unloadFile.deleteOnExit();
        }

        /**
         * Set to false, if you want to disable the unloading in a temporary file
         */
        public void setUnloading(boolean unloadingEnabled) {
                this.unloadingEnabled = unloadingEnabled;
        }

        /**
         * @return true, if unloading is enabled
         */
        public boolean isUnloadingEnabled() {
                return unloadingEnabled;
        }
}
1	mojays	2	package appl.data;
2
3			import java.io.File;
4			import java.io.Serializable;
5
6			import org.apache.log4j.LogManager;
7			import org.apache.log4j.Logger;
8
9			import appl.util.GeneralUtil;
10
11			/**
12			* Loads an object on demand with the help of an <code>DataLoader</code>. The
13			* unload() method unloads a serializable {@link Object} into a temporary folder
14			* on the hard disk. Unloading can be disabled via the
15			* {@link #setUnloading(boolean)} method.
16			*
17			* @see DataLoader
18			* @author Dominik Appl
19			*/
20			public class LateLoadingProxy implements DataProxy, Serializable {
21
22			private File unloadFile;
23
24			protected transient final Logger LOG = LogManager.getLogger(this.getClass()
25			.getName());
26
27			/** Object loaded? */
28			protected boolean loaded = false;
29
30			protected transient DataLoader dataLoader;
31
32			/**
33			* The loader which constructs the object
34			*/
35			protected transient DataLoader intialDataLoader;
36
37			protected Object baseObject;
38
39			private boolean unloadingEnabled;
40
41			/**
42			* Creates a new instance with the specified data loader
43			*
44			* @param loader
45			* the load method of the {@link DataLoader} is called for
46			* loading
47			*/
48			public LateLoadingProxy(DataLoader loader) {
49			if (loader == null) {
50			throw new UnsupportedOperationException(
51			"Error: the dataloader may not be null");
52			}
53			setUnloadDir("Temp");
54			this.intialDataLoader = loader;
55			this.dataLoader = loader;
56			}
57
58			private LateLoadingProxy() {
59			};
60
61			/**
62			* returns the File, in which the object is/will be unloaded
63			*/
64			protected File getUnloadFile() {
65			return unloadFile;
66			}
67
68			/**
69			* Loads the data into memory (if not already loaded).<br>
70			* This method is thread-safe
71			*
72			* @throws LoadingException
73			*/
74			public synchronized void loadData() throws LoadingException {
75			if (loaded)
76			return;
77			try {
78			if (dataLoader == null)
79			throw new UnsupportedOperationException(
80			"A dataloader was found to be null!");
81			baseObject = dataLoader.load();
82			if (LOG.isDebugEnabled())
83			LOG.debug("Successfully loaded " + baseObject + " with "
84			+ dataLoader.getLoadInfo());
85			loaded = true;
86
87			} catch (LoadingException e) {
88			throw e;
89			}
90			}
91
92			/***************************************************************************
93			* If no Data is loaded or unloading is disabled this method does nothing,
94			* else it saves the Data into a temporary File. <br>
95			* Warning: Should be Thread-Safe with loadData, but was not tested
96			**************************************************************************/
97			public synchronized void unloadData() {
98			// only do something if the Data is loaded and unloading is enabled:
99			if (!loaded)
100			return;
101			if (!unloadingEnabled)
102			return;
103			// there is no way to save the Grid to a File, when its not serializible
104			if (!(baseObject instanceof java.io.Serializable)) {
105			LOG.warn("Could not unload the Data because the class "
106			+ baseObject.getClass().getName() + "is not serializable");
107			return;
108			}
109
110			// unload the Data
111			try {
112			GeneralUtil.SerializeToFile(baseObject, unloadFile);
113			loaded = false;
114			baseObject = null;
115			dataLoader = new SerializedDataLoader(unloadFile, true);
116			LOG.debug("Successfully unloaded Grid into File: "
117			+ unloadFile.getPath());
118			} catch (Exception e) {
119			LOG.error("Error while trying to unload a grid into file '"
120			+ unloadFile.getAbsolutePath() + "'");
121			e.printStackTrace();
122			}
123
124			}
125
126			/**
127			* This class supports late loading, of course.
128			*
129			* @see appl.data.LateLoadable#unloadData()
130			* @return true;
131			* @see appl.data.LateLoadable#isLateLoadable()
132			*/
133			public boolean isLateLoadable() {
134			return true;
135			}
136
137			/**
138			* returns the baseObject
139			*
140			* @see appl.data.DataProxy#getProxiedObject()
141			*/
142			public Object getProxiedObject() {
143			try {
144			loadData();
145			} catch (LoadingException e) {
146			System.err.println("Error while loading Griddata ... ");
147			e.printStackTrace();
148			}
149			return baseObject;
150			}
151
152			/** returns true, if the baseObject is loaded */
153			public boolean isLoaded() {
154			return loaded;
155			}
156
157			public void setUnloadDir(String newUnloadDirectory) {
158			unloadFile = new File(newUnloadDirectory + File.separatorChar
159			+ this.toString() + ".tmp");
160			// the unload file will be deleted after the JVM shuts down (only after
161			// "normal" shutdown)
162			unloadFile.deleteOnExit();
163			}
164
165			/**
166			* Set to false, if you want to disable the unloading in a temporary file
167			*/
168			public void setUnloading(boolean unloadingEnabled) {
169			this.unloadingEnabled = unloadingEnabled;
170			}
171
172			/**
173			* @return true, if unloading is enabled
174			*/
175			public boolean isUnloadingEnabled() {
176			return unloadingEnabled;
177			}
178			}