dwrguiceservletmodule.java

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

/*
 * Copyright 2007 Tim Peierls
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.directwebremoting.guice;

import com.google.inject.AbstractModule;
import com.google.inject.TypeLiteral;
import com.google.inject.Provider;

import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.directwebremoting.ScriptSession;
import org.directwebremoting.ServerContext;
import org.directwebremoting.ServerContextFactory;
import org.directwebremoting.WebContext;
import org.directwebremoting.WebContextFactory;
import static org.directwebremoting.guice.DwrScopes.*;
import static org.directwebremoting.guice.DwrGuiceUtil.getServletContext;

/**
 * Configures DWR scopes and creates bindings for commonly
 * used objects related to those scopes: request, response,
 * script session, session, servlet context, and web context. 
 * <p>
 * Since Guice's ServletModule makes its own bindings for requests,
 * responses, and sessions, this class has a constructor that lets
 * the user specify whether to avoid conflicts by not binding these types.
 * </p>
 * @author Tim Peierls [tim at peierls dot net]
 */
class DwrGuiceServletModule extends AbstractModule 
{
    /**
     * Creates a module to configure DWR scopes and bindings;
     * conflicts with the bindings provided by Guice's {@link ServletModule}.
     * <p>
     * Normally you would not use this constructor directly, but instead call
     * {@link AbstractDwrModule#bindDwrScopes() bindDwrScopes} in your binding
     * code.
     * </p>
     */
    public DwrGuiceServletModule() 
    {
        this.bindPotentiallyConflictingTypes = true;
    }
    
    /**
     * Creates a module to configure DWR scopes and bindings;
     * conflicts with the bindings provided by Guice's {@link ServletModule}
     * unless {@code bindPotentiallyConflictingTypes} is false, in which 
     * case this module will not create its own bindings for requests, 
     * responses, and sessions.
     * <p>
     * Normally you would not use this constructor directly, but instead call
     * {@link AbstractDwrModule#bindDwrScopes(boolean) bindDwrScopes} in your binding
     * code.
     * </p>
     */
    public DwrGuiceServletModule(boolean bindPotentiallyConflictingTypes) 
    {
        this.bindPotentiallyConflictingTypes = bindPotentiallyConflictingTypes;
    }


    protected void configure() 
    {
        bindScope(RequestScoped.class, REQUEST);
        bindScope(SessionScoped.class, SESSION);
        bindScope(ScriptSessionScoped.class, SCRIPT);
        bindScope(ApplicationScoped.class, APPLICATION);
        bindScope(GlobalApplicationScoped.class, GLOBAL);
        
        if (bindPotentiallyConflictingTypes) 
        {
            // Use DWR request and session scopes for request, response, and session.
            
            Provider<HttpServletRequest> requestProvider =
                new Provider<HttpServletRequest>() 
                {
                    public HttpServletRequest get() 
                    {
                        WebContext webcx = WebContextFactory.get();
                        return webcx.getHttpServletRequest();
                    }

                    public String toString() 
                    {
                        return "RequestProvider";
                    }
                };
            bind(HttpServletRequest.class).toProvider(requestProvider);
            bind(ServletRequest.class).toProvider(requestProvider);

            Provider<HttpServletResponse> responseProvider =
                new Provider<HttpServletResponse>() 
                {
                    public HttpServletResponse get() 
                    {
                        WebContext webcx = WebContextFactory.get();
                        return webcx.getHttpServletResponse();
                    }

                    public String toString() 
                    {
                        return "ResponseProvider";
                    }
                };
            bind(HttpServletResponse.class).toProvider(responseProvider);
            bind(ServletResponse.class).toProvider(responseProvider);
                
            Provider<HttpSession> sessionProvider = 
                new Provider<HttpSession>() 
                {
                    public HttpSession get() 
                    {
                        WebContext webcx = WebContextFactory.get();
                        return webcx.getSession();
                    }

                    public String toString() 
                    {
                        return "SessionProvider";
                    }
                };
            bind(HttpSession.class).toProvider(sessionProvider);
        } 

        Provider<Map<String, String[]>> requestParametersProvider =
            new Provider<Map<String, String[]>>() 
            {
                @SuppressWarnings({"unchecked"})
                public Map<String, String[]> get() 
                {
                    WebContext webcx = WebContextFactory.get();
                    return webcx.getHttpServletRequest().getParameterMap();
                }

                public String toString() 
                {
                    return "RequestParametersProvider";
                }
            };           
        bind(new TypeLiteral<Map<String, String[]>>() {})
            .annotatedWith(RequestParameters.class)
            .toProvider(requestParametersProvider);

       
        Provider<ScriptSession> scriptSessionProvider =
            new Provider<ScriptSession>() 
            {
                public ScriptSession get() 
                {
                    WebContext webcx = WebContextFactory.get();
                    return webcx.getScriptSession();
                }

                public String toString() 
                {
                    return "ScriptSessionProvider";
                }
            };
        bind(ScriptSession.class).toProvider(scriptSessionProvider);
        
        Provider<ServletContext> servletContextProvider =
            new Provider<ServletContext>() 
            {
                public ServletContext get() 
                {
                    // Can work even if WebContext isn't found.
                    return getServletContext();
                }

                public String toString() 
                {
                    return "ServletContextProvider";
                }
            };            
        bind(ServletContext.class).toProvider(servletContextProvider);
        
        Provider<WebContext> webContextProvider =
            new Provider<WebContext>() 
            {
                public WebContext get() 
                {
                    return WebContextFactory.get();
                }

                public String toString() 
                {
                    return "WebContextProvider";
                }
            };            
        bind(WebContext.class).toProvider(webContextProvider);
        
        Provider<ServerContext> serverContextProvider =
            new Provider<ServerContext>() 
            {
                public ServerContext get() 
                {
                    return ServerContextFactory.get(getServletContext());
                }

                public String toString() 
                {
                    return "ServerContextProvider";
                }
            };            
        bind(ServerContext.class).toProvider(serverContextProvider);
    }

    
    private final boolean bindPotentiallyConflictingTypes;
}