/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.servlet;import javax.servlet.*;import javax.servlet.http.*;import java.io.*;import java.util.*;/** * This servlet maintains an arbitrary set of counter variables and increments * and displays the value of one named counter each time it is invoked.  It * saves the state of the counters to a disk file, so the counts are not lost * when the server shuts down.  It is suitable for counting page hits, or any * other type of event.  It is not typically invoked directly, but is included * within other pages, using JSP, SSI, or a RequestDispatcher **/public class Counter extends HttpServlet {    HashMap counts;      // A hash table: maps counter names to counts    File countfile;      // The file that counts are saved in    long saveInterval;   // How often (in ms) to save our state while running?    long lastSaveTime;   // When did we last save our state?    // This method is called when the web server first instantiates this    // servlet.  It reads initialization parameters (which are configured    // at deployment time in the web.xml file), and loads the initial state    // of the counter variables from a file.    public void init() throws ServletException {	ServletConfig config = getServletConfig();	try {	    // Get the save file.	    countfile = new File(config.getInitParameter("countfile"));	    // How often should we save our state while running?	    saveInterval = 		Integer.parseInt(config.getInitParameter("saveInterval"));	    // The state couldn't have changed before now.	    lastSaveTime = System.currentTimeMillis();	    // Now read in the count data	    loadState();	}	catch(Exception e) {	    // If something goes wrong, wrap the exception and rethrow it	    throw new ServletException("Can't init Counter servlet: " +				       e.getMessage(), e);	}    }    // This method is called when the web server stops the servlet (which    // happens when the web server is shutting down, or when the servlet is    // not in active use.)  This method saves the counts to a file so they    // can be restored when the servlet is restarted.    public void destroy() {	try { saveState(); }  // Try to save the state	catch(Exception e) {} // Ignore any problems: we did the best we could    }    // These constants define the request parameter and attribute names that    // the servlet uses to find the name of the counter to increment.    public static final String PARAMETER_NAME = "counter";    public static final String ATTRIBUTE_NAME =	"com.davidflanagan.examples.servlet.Counter.counter";    /**     * This method is called when the servlet is invoked.  It looks for a     * request parameter named "counter", and uses its value as the name of     * the counter variable to increment.  If it doesn't find the request     * parameter, then it uses the URL of the request as the name of the     * counter.  This is useful when the servlet is mapped to a URL suffix.     * This method also checks how much time has elapsed since it last saved     * its state, and saves the state again if necessary.  This prevents it     * from losing too much data if the server crashes or shuts down without     * calling the destroy() method.     **/    public void doGet(HttpServletRequest request, HttpServletResponse response)        throws IOException    {	// Get the name of the counter as a request parameter	String counterName = request.getParameter(PARAMETER_NAME);		// If we didn't find it there, see if it was passed to us as a	// request attribute, which happens when the output of this servlet	// is included by another servlet	if (counterName == null)	    counterName = (String) request.getAttribute(ATTRIBUTE_NAME);	// If it wasn't a parameter or attribute, use the request URL.	if (counterName == null) counterName = request.getRequestURI();	Integer count;  // What is the current count?	// This block of code is synchronized because multiple requests may	// be running at the same time in different threads.  Synchronization	// prevents them from updating the counts hashtable at the same time	synchronized(counts) {	    // Get the counter value from the hashtable	    count = (Integer)counts.get(counterName);	    	    // Increment the counter, or if it is new, log and start it at 1	    if (count != null) count = new Integer(count.intValue() + 1);	    else {		// If this is a counter we haven't used before, send a message		// to the log file, just so we can track what we're counting		log("Starting new counter: " + counterName);		// Start counting at 1!		count = new Integer(1);	    }	    	    // Store the incremented (or new) counter value into the hashtable	    counts.put(counterName, count);	    // Check whether saveInterval milliseconds have elapsed since we	    // last saved our state.  If so, save it again.  This prevents	    // us from losing more than saveInterval ms of data, even if the	    // server crashes unexpectedly.  	    if (System.currentTimeMillis() - lastSaveTime > saveInterval) {		saveState();		lastSaveTime = System.currentTimeMillis();	    }	}  // End of synchronized block		// Finally, output the counter value.  Since this servlet is usually	// included within the output of other servlets, we don't bother	// setting the content type.	PrintWriter out = response.getWriter();	out.print(count);    }    // The doPost method just calls doGet, so that this servlet can be    // included in pages that are loaded with POST requests    public void doPost(HttpServletRequest request,HttpServletResponse response)        throws IOException    {	doGet(request, response);    }    // Save the state of the counters by serializing the hashtable to    // the file specified by the initialization parameter.    void saveState() throws IOException {	ObjectOutputStream out = new ObjectOutputStream(		    new BufferedOutputStream(new FileOutputStream(countfile)));	out.writeObject(counts);  // Save the hashtable to the stream	out.close();              // Always remember to close your files!    }    // Load the initial state of the counters by de-serializing a hashtable    // from the file specified by the initialization parameter.  If the file    // doesn't exist yet, then start with an empty hashtable.    void loadState() throws IOException {	if (!countfile.exists()) {	    counts = new HashMap(); 	    return;	}	ObjectInputStream in = null;	try {	    in = new ObjectInputStream(		   new BufferedInputStream(new FileInputStream(countfile)));	    counts = (HashMap) in.readObject();	}	catch(ClassNotFoundException e) {	    throw new IOException("Count file contains bad data: " +				  e.getMessage());	}	finally {	    try { in.close(); }	    catch (Exception e) {}	}    }}