java - simple - Cómo validar una solicitud a una página JSP en Struts2

mvc example java servlet jsp

Question

Una solicitud a una Acción se puede validar utilizando los Interceptores. Además, se puede evitar la solicitud directa a una página JSP usando una declaración de acción vacía. Es algo como esto;

<action name="home" >
        <result>home.jsp</result>
</action>  

Quiero validar esta llamada a la página JSP. Como considero que un enfoque simple puede ser agregar una Acción ( ActionSupport Acción) con un Interceptor que verifique el nombre de la acción (y valide con la sesión, etc.). Pero tengo una duda de si reduce el rendimiento, porque esa clase de acción no hace nada y solo ejecuta su execute() solamente (tarea inútil ...), y donde debería haber una Acción vacía . (PERO: como he leído algunos documentos en Struts2, se dice que aunque no agreguemos un Action calss, el framework agrega una clase de acción que devuelve "success", por lo tanto, agregar una clase de acción o no a nosotros mismos, no afecta recién)

De todos modos, me gustaría saber cuáles son sus mejores enfoques para validar o autorizar el acceso a algunas páginas JSP (el número de páginas puede ser muchas ... no solo para una página jsp)

Agregado: Ejemplo:
Digamos que, hay algunas páginas restringidas donde todos los usuarios no pueden tener acceso, por ejemplo, la página de la cuenta del usuario solo se puede visitar a los usuarios que hayan iniciado sesión. Puede haber más de ese tipo de páginas. Si una solicitud llega a dicha página, el usuario debe ser validado. Luego, si la solicitud proviene de una acción vacía / anónima (como se explicó en el código anterior, solo nombre de la acción-no clase real) cómo validar dichas solicitudes a Páginas JSP? ¿Debería usarse una clase de acción para esto?

Answer 1

// Esto es para autorización

package com.kogent.action;

import java.io.IOException;
import java.util.List;
import java.util.regex.Pattern;

import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.dispatcher.Dispatcher;
import org.apache.struts2.dispatcher.mapper.ActionMapping;
import org.apache.struts2.dispatcher.ng.ExecuteOperations;
import org.apache.struts2.dispatcher.ng.InitOperations;
import org.apache.struts2.dispatcher.ng.PrepareOperations;
import org.apache.struts2.dispatcher.ng.filter.FilterHostConfig;
import org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter;

public class SessionController extends StrutsPrepareAndExecuteFilter {
    protected PrepareOperations prepare;
    protected ExecuteOperations execute;
    protected List<Pattern> excludedPatterns = null;

public void init(FilterConfig filterConfig) throws ServletException {
    InitOperations init = new InitOperations();
    try {
        FilterHostConfig config = new FilterHostConfig(filterConfig);
        init.initLogging(config);
        Dispatcher dispatcher = init.initDispatcher(config);
        init.initStaticContentLoader(config, dispatcher);

        prepare = new PrepareOperations(filterConfig.getServletContext(),
                dispatcher);
        execute = new ExecuteOperations(filterConfig.getServletContext(),
                dispatcher);
        this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);

        postInit(dispatcher, filterConfig);
    } finally {
        init.cleanup();
    }

}

/**
 * Callback for post initialization
 */
protected void postInit(Dispatcher dispatcher, FilterConfig filterConfig) {
}

public void doFilter(ServletRequest req, ServletResponse res,
        FilterChain chain) throws IOException, ServletException {

    HttpServletRequest request = (HttpServletRequest) req;
    HttpServletResponse response = (HttpServletResponse) res;

    try {
        prepare.setEncodingAndLocale(request, response);
        prepare.createActionContext(request, response);
        prepare.assignDispatcherToThread();
        if (excludedPatterns != null
                && prepare.isUrlExcluded(request, excludedPatterns)) {
            chain.doFilter(request, response);
        } else {
            request = prepare.wrapRequest(request);
            ActionMapping mapping = prepare.findActionMapping(request,
                    response, true);
            if (mapping == null) {
                boolean handled = execute.executeStaticResourceRequest(
                        request, response);
                if (!handled) {
                    chain.doFilter(request, response);
                }
            } else {
                //here you have to identify the whether the user have access to requested resource or not 
                //allow him if he was access.
                //if(someCondition)
                execute.executeAction(request, response, mapping);
                //else{
                //redirect the user how do you want it to be.
                ActionMapping modfiedActionMapping = new ActionMapping();
                modfiedActionMapping.setName("someActionName");
                modfiedActionMapping.setNamespace("someNameSpace");
                execute.executeAction(request, response, modfiedActionMapping);

            //}

            }
        }
    } finally {
        prepare.cleanupRequest(request);
    }
}

public void destroy() {
    prepare.cleanupDispatcher();
}

}

<filter>
    <filter-name>struts2</filter-name>
    <filter-class>Point to your customized filter</filter-class>
</filter>

Answer 2

Si su atención es asegurar una parte de su aplicación para que solo Autenticado así como autorizar el uso pueda acceder a esa parte, entonces usted tiene dos opciones

1. Use una autenticación basada en un interceptor
2. Usuario una API de seguridad como Spring -security

La autenticación basada en interceptor es bastante fácil. Aquí hay un ejemplo de cómo hacer esto, pero dicha autenticación no se recomienda para una aplicación basada en la producción y en la vida real, ya que es un caso realmente simple.

Si está buscando un sistema de autenticación completo, le sugiero que mire la seguridad Spring. Es bastante fácil y configurable, todo lo que necesita para contarle al mecanismo de resorte subyacente que todas las áreas y bajo etiqueta segura y seguridad Spring los interceptarán antes de su acción ser llamado y solo exitoso y autorizar acción será llamado por la seguridad de primavera.