Ajax による JSF フォームの自動保存: 第 2 回

                
package autosave;
...
import javax.servlet.http.Cookie;
...
public class BrowserIdFilter implements Filter {
    public static String BROWSERID = "BROWSERID"; // cookie name

    public static String getBrowserId(HttpServletRequest httpRequest) {
        String browserId = null;
        Cookie cookies[] = httpRequest.getCookies();
        if (cookies != null)
            for (int i = 0; i < cookies.length; i++) {
                if (BROWSERID.equals(cookies[i].getName())) {
                    browserId = cookies[i].getValue();
                    break;
                }
            }
        return browserId;
    }
    ...
}

                
package autosave;
...
import javax.servlet.Filter;
import javax.servlet.FilterChain;
...
public class BrowserIdFilter implements Filter {
    public static String BROWSERID = "BROWSERID"; // cookie name
    public static int IDAGE = 3600 * 24 * 365 * 3; // three years
    ...
    public void doFilter(ServletRequest request,
            ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        if (getBrowserId(httpRequest) == null) {
            // The BROWSERID cookie has not been found. This must be
            // the first time the user accesses the application.
            // Use the current session's ID as the value for
            // the BROWSERID cookie.
            HttpServletResponse httpResponse
                = (HttpServletResponse) response;
            String browserId = httpRequest.getSession().getId();
            Cookie browserCookie = new Cookie(BROWSERID, browserId);
            browserCookie.setMaxAge(IDAGE);
            browserCookie.setPath(httpRequest.getContextPath());
            httpResponse.addCookie(browserCookie);
        }
        chain.doFilter(request, response);
    }
    ...
}

                
<web-app ...>
    ...
    <filter>
        <filter-name>BrowserIdFilter</filter-name>
        <filter-class>autosave.BrowserIdFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>BrowserIdFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    ...
</web-app>

                
package autosave;
...
import javax.faces.component.EditableValueHolder;
import javax.faces.component.UIComponent;
...
public class DataMapRepository ... {
    ...
    public static void saveValues(UIComponent comp,
            Map<String, Object> dataMap) {
        if (comp == null)
            return;
        if (comp instanceof EditableValueHolder) {
            // Input component. Put its value into the data map
            EditableValueHolder evh = (EditableValueHolder) comp;
            dataMap.put(comp.getId(), evh.getValue());
        }
        // Iterate over the children of the current component
        Iterator children = comp.getChildren().iterator();
        while (children.hasNext()) {
            UIComponent child = (UIComponent) children.next();
            // Recursive call
            saveValues(child, dataMap);
        }
    }
    ...
}

                
package autosave;
...
import javax.faces.component.EditableValueHolder;
import javax.faces.component.UIComponent;
...
public class DataMapRepository ... {
    ...
    public static void restoreValues(UIComponent comp,
            Map<String, Object> dataMap) {
        if (comp == null || dataMap == null)
            return;
        if (comp instanceof EditableValueHolder) {
            // Input component. Get its value from the data map
            // and clear any submitted value
            EditableValueHolder evh = (EditableValueHolder) comp;
            evh.setValue(dataMap.get(comp.getId()));
            evh.setSubmittedValue(null);
        }
        // Iterate over the children of the current component
        Iterator children = comp.getChildren().iterator();
        while (children.hasNext()) {
            UIComponent child = (UIComponent) children.next();
            // Recursive call
            restoreValues(child, dataMap);
        }
    }

}

                
package autosave;
...
import javax.faces.component.UIViewRoot;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
...
import java.security.Principal;
...
public class DataMapRepository ... {
    ...
    public static String getDataMapId(FacesContext ctx) {
        UIViewRoot root = ctx.getViewRoot();
        if (root == null)
            return null;
        ExternalContext ectx = ctx.getExternalContext();
        String userId = null;
        Principal principal = ectx.getUserPrincipal();
        if (principal != null) {
            // Use the name of the authenticated user.
            userId = principal.getName();
        } else {
            // Use the browser ID of the anonymous user.
            userId = BrowserIdFilter.getBrowserId(
                    (HttpServletRequest) ectx.getRequest());
        }
        if (userId == null)
            return null;
        // Concatenate the user ID and the JSF view ID
        return userId + root.getViewId();
    }
    ...
}

                
package autosave;
...
import java.util.LinkedHashMap;
import java.util.Map;

public class DataMapRepository
        extends LinkedHashMap<String, Map<String, Object>> {
    private static final int DEFAULT_MAX_DATA_MAPS = 1000;
    private int maxDataMaps;

    public DataMapRepository() {
        maxDataMaps = DEFAULT_MAX_DATA_MAPS;
    }
    
    public DataMapRepository(DataMapRepository repository) {
        maxDataMaps = repository.maxDataMaps;
        putAll(repository);
    }
    
    public int getMaxDataMaps() {
        return maxDataMaps;
    }

    public void setMaxDataMaps(int maxDataMaps) {
        this.maxDataMaps = maxDataMaps;
    }

    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > maxDataMaps;
    }
    ...
}

                
package autosave;
...
public class DataMapRepository ... {
    ...
    public Map<String, Object> getDataMap(FacesContext ctx) {
        String id = getDataMapId(ctx);
        if (id == null)
            return null;
        return get(id);
    }
    
    public void setDataMap(FacesContext ctx, Map<String, Object> dataMap) {
        String id = getDataMapId(ctx);
        if (id == null)
            return;
        if (dataMap != null)
            put(id, dataMap);
        else
            remove(id);
    }
    ...
}

                
package autosave;
...
public class RepositoryWrapper implements java.io.Serializable {
    private DataMapRepository repository;
    
    public RepositoryWrapper() {
        repository = new DataMapRepository();
    }
    
    public synchronized DataMapRepository getRepository() {
        return new DataMapRepository(repository);
    }

    public synchronized void setRepository(
            DataMapRepository repository) {
        if (repository != null)
            this.repository = new DataMapRepository(repository);
        else
            this.repository.clear();
    }
    ...
}

                
package autosave;
...
import javax.faces.context.FacesContext;
...
import java.util.Map;

public class RepositoryWrapper implements java.io.Serializable {
    ...
    public synchronized Map<String, Object> getDataMap(
            FacesContext ctx) {
        return repository.getDataMap(ctx);
    }
    
    public synchronized void setDataMap(FacesContext ctx,
            Map<String, Object> dataMap) {
        repository.setDataMap(ctx, dataMap);
    }
    
    public synchronized boolean hasDataMap(FacesContext ctx) {
        return getDataMap(ctx) != null;
    }
    
    public synchronized void clearDataMap(FacesContext ctx) {
        setDataMap(ctx, null);
    }
    
    public synchronized int getMaxDataMaps() {
        return repository.getMaxDataMaps();
    }

    public synchronized void setMaxDataMaps(int maxDataMaps) {
        repository.setMaxDataMaps(maxDataMaps);
    }
    ...
}

                
<faces-config>
    ...
    <managed-bean>
        <managed-bean-name>repositoryWrapper</managed-bean-name>
        <managed-bean-class>autosave.RepositoryWrapper</managed-bean-class>
        <managed-bean-scope>application</managed-bean-scope>
        ...
        <managed-property>
            <property-name>maxDataMaps</property-name>
            <value>100</value>
        </managed-property>
    </managed-bean>
    ...
</faces-config>

                
package autosave;

import javax.faces.application.Application;
import javax.faces.context.FacesContext;
import javax.faces.el.ValueBinding;

import javax.servlet.ServletContext;
...
public class RepositoryWrapper implements java.io.Serializable {
    ...
    public static RepositoryWrapper getManagedBean(FacesContext ctx) {
        Application app = ctx.getApplication();
        ValueBinding vb = app.createValueBinding("#{repositoryWrapper}");
        return (RepositoryWrapper) vb.getValue(ctx);
    }

    public static RepositoryWrapper getManagedBean(ServletContext ctx) {
        return (RepositoryWrapper) ctx.getAttribute("repositoryWrapper");
    }

}

                
package autosave;
...
import javax.faces.component.UIViewRoot;
import javax.faces.context.FacesContext;
...
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class AutoSaveListener implements PhaseListener {
    ...
    public void saveCurrentView() {
        // Get the faces context of the current request.
        FacesContext ctx = FacesContext.getCurrentInstance();
        // Get the root component of the current view.
        UIViewRoot root = ctx.getViewRoot();
        // Create a new data map.
        Map<String, Object> dataMap = new HashMap<String, Object>();
        // Store the component values into the data map.
        DataMapRepository.saveValues(root, dataMap);
        // Make the data map unmodifiable.
        dataMap = Collections.unmodifiableMap(dataMap);
        // Get the managed bean instance wrapping the data repository.
        RepositoryWrapper wrapper = RepositoryWrapper.getManagedBean(ctx);
        // Store the data map into the repository.
        wrapper.setDataMap(ctx, dataMap);
        // Stop request processing.
        ctx.responseComplete();
    }
    ...
}

                
package autosave;
...
import javax.faces.context.FacesContext;
import javax.faces.event.PhaseEvent;
import javax.faces.event.PhaseId;
import javax.faces.event.PhaseListener;
...
public class AutoSaveListener implements PhaseListener {
    ...
    public void afterPhase(PhaseEvent e) {
        if (!e.getPhaseId().equals(PhaseId.PROCESS_VALIDATIONS))
            return;
        FacesContext ctx = e.getFacesContext();
        Map headers = ctx.getExternalContext().getRequestHeaderMap();
        if ("Auto-Save".equals(headers.get("Ajax-Request"))) {
            // Auto-Save Request. Save data into the repository.
            saveCurrentView();
        } else {
            // The user must have clicked the Submit button.
            if (!ctx.getMessages().hasNext()) {
                // There are no error messages.
                // This means the final submitted data is valid and
                // the temporary auto-saved data is no longer needed.
                RepositoryWrapper wrapper
                    = RepositoryWrapper.getManagedBean(ctx);
                wrapper.clearDataMap(ctx);
            }
        }
    }
    ...
}

                
package autosave;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextListener;
...
import java.io.File;

public class DataMapPersistence implements ServletContextListener {

    private File getDataFile(ServletContext sctx) {
        String path = sctx.getRealPath("/WEB-INF/repository.ser");
        if (path == null)
            return null;
        return new File(path);
    }
    ...
}

                package autosave;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
...
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class DataMapPersistence implements ServletContextListener {
    ...    
    public void contextInitialized(ServletContextEvent e) {
        ServletContext sctx = e.getServletContext();
        File dataFile = getDataFile(sctx);
        if (dataFile == null || !dataFile.exists())
            return;
        try {
            ObjectInputStream in = new ObjectInputStream(
                    new BufferedInputStream(
                    new FileInputStream(dataFile)));
            try {
                // Read the data repository from the file.
                Object repository = in.readObject();
                // Store the loaded repository into the application scope.
                sctx.setAttribute("loadedRepository", repository);
            } finally {
                in.close();
            }
        } catch (Exception x) {
            sctx.log("Loading Error", x);
        }
    }
    ...
}

                
<faces-config>
    ...
    <managed-bean>
        <managed-bean-name>repositoryWrapper</managed-bean-name>
        <managed-bean-class>autosave.RepositoryWrapper</managed-bean-class>
        <managed-bean-scope>application</managed-bean-scope>
        <managed-property>
            <property-name>repository</property-name>
            <value>#{loadedRepository}</value>
        </managed-property>
        ...
    </managed-bean>
    ...
</faces-config>

                
package autosave;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
...
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class DataMapPersistence implements ServletContextListener {
    ...    
    public void contextDestroyed(ServletContextEvent e) {
        ServletContext sctx = e.getServletContext();
        File dataFile = getDataFile(sctx);
        if (dataFile == null)
            return;
        try {
            ObjectOutputStream out = new ObjectOutputStream(
                    new BufferedOutputStream(
                    new FileOutputStream(dataFile)));
            try {
                // Get a copy of the data repository from the wrapper bean.
                RepositoryWrapper wrapper
                    = RepositoryWrapper.getManagedBean(sctx);
                Object repository = wrapper.getRepository();
                // Serialize the data repository into the file.
                out.writeObject(repository);
            } finally {
                out.close();
            }
        } catch (Exception x) {
            sctx.log("Saving Error", x);
        }
    }

}

                
<web-app ...>
    ...
    <listener>
        <listener-class>autosave.DataMapPersistence</listener-class>
    </listener>
    ...
</web-app>