fluentconfigurator.java

反向的AJAX。最大的特性是我们成为反向的Ajax。DWR1.x允许你用javascript异步的访问java代码。DWR2.0在这上允许你建立异步java访问javascript代码。 反向的Aj

package org.directwebremoting.fluent;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.directwebremoting.AjaxFilter;
import org.directwebremoting.Container;
import org.directwebremoting.extend.AccessControl;
import org.directwebremoting.extend.AjaxFilterManager;
import org.directwebremoting.extend.Configurator;
import org.directwebremoting.extend.Converter;
import org.directwebremoting.extend.ConverterManager;
import org.directwebremoting.extend.Creator;
import org.directwebremoting.extend.CreatorManager;
import org.directwebremoting.impl.SignatureParser;
import org.directwebremoting.util.LocalUtil;
import org.directwebremoting.util.Logger;

/**
 * A {@link Configurator} that used the FluentInterface style as
 * <a href="http://www.martinfowler.com/bliki/FluentInterface.html">described by
 * Martin Fowler</a>.
 *
 * <p>To wire up the configuration programatically rather than having to use
 * <code>dwr.xml</code>. In order to use this style, you'll need to:</p>
 *
 * <ul>
 * <li>Create a concrete implementation of {@link FluentConfigurator} which
 * implements the {@link #configure()} method.</li>
 * <li>Add an init param '<code>customConfigurator</code>' to the DWR servlet in
 * <code>web.xml</code> to point at your new class.</li>
 * </ul>
 *
 * <p>The implementation of {@link #configure()} will look something like
 * this:</p>
 *
 * <pre>
 * public void configure() {
 *    withConverterType("dog", "com.yourcompany.beans.Dog");
 *    withCreatorType("ejb", "com.yourcompany.dwr.creator.EJBCreator");
 *    withCreator("new", "ApartmentDAO")
 *        .addParam("scope", "session")
 *        .addParam("class", "com.yourcompany.dao.ApartmentDAO")
 *        .exclude("saveApartment")
 *        .withAuth("method", "role");
 *    withCreator("struts", "DogDAO")
 *        .addParam("clas", "com.yourcompany.dao.DogDAO")
 *        .include("getDog")
 *        .include("getColor");
 *    withConverter("dog", "*.Dog")
 *        .addParam("name", "value");
 *    withSignature()
 *        .addLine("import java.util.List;")
 *        .addLine("import com.example.Check;")
 *        .addLine("Check.setLotteryResults(List<Integer> nos);");
 * }
 * </pre>
 * @author Aaron Johnson [ajohnson at cephas dot net / <a href="http://cephas.net/blog">http://cephas.net/blog</a>]
 * @author Joe Walker [joe at getahead dot ltd dot uk]
 */
public abstract class FluentConfigurator implements Configurator
{
    /**
     * This method is used to configure DWR using the fluent style.
     */
    public abstract void configure();

    /**
     * Add a new {@link Converter} definition.
     * @param id The id referred to by the {@link #withConverter(String, String)}
     * @param converterClassName The implementation of {@link Converter} to instansitate.
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator withConverterType(String id, String converterClassName)
    {
        setState(STATE_INIT_CONVERT);
        converterManager.addConverterType(id, converterClassName);
        return this;
    }

    /**
     * Use a {@link Converter} to instansiate a class
     * @param newConverter A predefined {@link Converter} or one defined by
     * {@link #withConverterType(String, String)}.
     * @param newMatch The javascript name of this component
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator withConverter(String newConverter, String newMatch)
    {
        setState(STATE_ALLOW_CONVERT);
        this.converter = newConverter;
        this.match = newMatch;
        return this;
    }

    /**
     * Add a new {@link Creator} definition.
     * @param id The id referred to by the {@link #withCreator(String, String)}
     * @param creatorClassName The implementation of {@link Creator} to instansitate.
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator withCreatorType(String id, String creatorClassName)
    {
        setState(STATE_INIT_CREATE);
        creatorManager.addCreatorType(id, creatorClassName);
        return this;
    }

    /**
     * Use a {@link Creator} to instansiate a class
     * @param newTypeName A predefined {@link Creator} or one defined by
     * {@link #withCreatorType(String, String)}.
     * @param newScriptName The javascript name of this component
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator withCreator(String newTypeName, String newScriptName)
    {
        setState(STATE_ALLOW_CREATE);
        this.typeName = newTypeName;
        this.scriptName = newScriptName;
        return this;
    }
    
    /**
     * @param newFilterClassName filter class name
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator withFilter(String newFilterClassName)
    {
        setState(STATE_ALLOW_FILTER);
        this.filterClassName = newFilterClassName;
        return this;
    }

    /**
     * Add a parameter to whatever is being configured.
     * @param name The name of the parameter
     * @param value The value of the parameter
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator addParam(String name, String value)
    {
        if (params == null)
        {
            params = new HashMap();
        }

        params.put(name, value);
        return this;
    }

    /**
     * Add a filter to whatever is being configured.
     * @param newFilterClassName The class to add as a filter
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator addFilter(String newFilterClassName)
    {
        if (filters == null)
        {
            filters = new ArrayList();
        }

        filters.add(newFilterClassName);
        return this;
    }

    /**
     * Add an include rule to a {@link Creator}.
     * This should be used during a {@link #withCreator(String, String)} call.
     * @param methodName The method name to be allowed
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator include(String methodName)
    {
        accessControl.addIncludeRule(scriptName, methodName);
        return this;
    }

    /**
     * Add an exclude rule to a {@link Creator}
     * This should be used during a {@link #withCreator(String, String)} call.
     * @param methodName The method name to be dis-allowed
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator exclude(String methodName)
    {
        accessControl.addExcludeRule(scriptName, methodName);
        return this;
    }

    /**
     * Add an authorization rule to a {@link Creator}
     * This should be used during a {@link #withCreator(String, String)} call.
     * @param methodName The method name to have a required role
     * @param role The required role for the given method
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator withAuth(String methodName, String role)
    {
        accessControl.addRoleRestriction(scriptName, methodName, role);
        return this;
    }

    /**
     * Add lines to a signature.
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator withSignature()
    {
        setState(STATE_SIGNATURE);
        return this;
    }

    /**
     * Add lines to a signature.
     * @param line The line of text to add to the signature configuration
     * @return <code>this</code> to continue the fluency
     */
    public FluentConfigurator addLine(String line)
    {
        if (null == line)
        {
            return this;
        }

        if (null == signature)
        {
            signature = new StringBuffer();
        }

        signature.append(line);
        signature.append(System.getProperty("line.separator"));

        return this;
    }

    /**
     * Because some parts of the configuration require multiple steps, the instance
     * needs to maintain a state across invocations. Whenever the state is changed
     * by calling this method, the instance will 'flush' anything in the queue
     * applicable to that state EVEN IF the state itself doesn't change. Thus, it's
     * important that the child methods don't call setState() when being invoked.
     * @param state The new state. See the STATE_* constants.
     */
    private void setState(int state)