El desarrollo de la acción se completa heredando la clase ActionSupport. La clase ActionSupport no solo implementa la interfaz de acción, sino que también agrega soporte para la verificación y la localización. Las acciones personalizadas en el desarrollo real deben heredar esta clase. Agregar función de verificación de formulario al inicio de sesión del usuario
El papel de la clase de acciones:
STRUTS2 no requiere la clase de acción que diseñamos para heredar cualquier interfaz de clase base de Struts o Struts, pero para facilitar la implementación de nuestras propias acciones, heredaremos el método com.opensymphony.xwork2.Actionsupport en la mayoría de los casos, y anularemos el método de excepción de String Public String en esta clase. Debido a que hay muchas excusas prácticas en esta clase, se proporcionan muchos métodos predeterminados, incluidos los métodos de información internacional, métodos predeterminados para procesar las solicitudes de los usuarios, etc., que pueden simplificar enormemente el desarrollo de ACion. En Struts2, la acción generalmente se usa directamente para encapsular los parámetros de solicitud HTTP. Por lo tanto, la clase de acción también debe incluir atributos correspondientes a los parámetros de solicitud, y proporcionar métodos de Getter y Setter correspondientes para los atributos.
Entonces, ¿cuál es la diferencia entre la interfaz de acción y la clase ActionSupport?
La interfaz de acción tiene:
Public static final String Success = "Success"; public static final String None = "None"; public static final String error = "Error"; public static final String login = "Login"; public String Execute () lanza excepción;
Puede ver que hay cinco constantes estáticas y ejecutar () con cadena de tipo de retorno
Sobre la base de la implementación de la interfaz de acción, la clase de herramienta ActionSupport también define un método Validate (). Si el método se anula, se ejecutará antes del método Execute (). Si la verificación falla, se transferirá a la entrada. El atributo de entrada debe configurarse al configurar la acción.
Además, ActionSupport también proporciona un método GetText (clave de cadena) y realiza la internacionalización, que obtiene información de internacionalización de archivos de recursos.
De esta manera, al personalizar la etiqueta, puede definir una variable como un nuevo objeto de acciones para lograr la internacionalización.
La clase ActionSupport tiene (código fuente):
Public Class ActionSupport implementa la acción, Validatable, ValidationAware, TextProvider, LocalProvider, serializable {protegido estático Logger log = logGerFactory.getLogger (ActionSupport.Class); Validación final privada AwaresUpport ValidationAware = New ValidationAwAresupport (); PRIVADO TEXTPRESTO TEXTPRESTRADO; Concicaptador de contenedor privado; Concicaciente de contenido privado; contenedor de contenido privado contenedor contenedor de contenedor público; contenedor público privado contenedor; setActionErrors (colección <String> errorMessages) {validationAware.SetActionErrors (errorMessages);} public colección public <string> getActionErrors () {return ValidationAware.getActionErrors ();} public void setActionMessages (colección <tred> mensajes) {validationAweAs.SetActionMessages (mensajes);} colección pública <string> getActionMessMessMessage () validationAware.getActionMessages ();}@deprecedpublic colección <string> getRormesSages () {return getActionErrors ();}@deprecedpublic maps map <string, list <string>> getErrors () {return getFielderRors ();} public void setfielderrors (map <string <string <string>> Errormap) {validationAware.setFieldERRors (errorMap);} public map <String, List <String>> getFielderRors () {return ValidationAware.getFielderRors ();} public locale getLocale () {ActionContext ctx = acciónContext.getContex {if (log.isDeBugeNable ()) {log.deBug ("Action Context no inicializado");} return null;}} public boolean Haskey (key de cadena) {return getTextProvider (). Haskey (key);} public string getText (string atextName) {returnTextProvider (). gettex atextName, string defaultValue) {return getTextProvider (). getText (atextName, defaultValue);} public String getText (string atextName, string defaultValue, string obj) {return getTextProvider (). getText (atextName, defaultValue, obj);} public string getTex getTextProvider (). args);} public String getText (clave de cadena, cadena defaultValue, string [] args) {return getTextProvider (). getText (key, defaultValue, args);} public String getText (string key, string defaultValue, list <?>, valueStack stack) {returnTxtProvider (). String getText (clave de cadena, string defaultValue, string [] args, valueSestack stack) {return getTextProvider (). GetText (key, defaultValue, args, stack);} public String getFormatted (string key, string expr) {map <string, object> conversionErrors = ActionContext.getContext (). GetConversionRors ();); (conversionErrors.containskey (exp)) {string [] vals = (string []) conversionErrors.get (expr); return vals [0];} else {final valueSestack valueSestack = ActionContext.getContex Arrays.aslist (val));}} public recourCeBundle getTexts () {return getTextProvider (). GetTexts ();} public recouteBUndle getTexts (string abundLename) {return getTextProvider (). GetTexts (nombre {validationAware.AdDactionError (anerrormessage);} public void addactionMessage (String amessage) {validationAware.addactionMessage (amessage);} public void addFielderRor (string fieldName, string errorMessage) {validationAware.addfielderror (fieldName, errorMessage);} String ErrMessage () {ValidationAware Entrada;} public String Dodefault () lanza Exception {return Success;} public String Execute () arroja excepción {return éxito;} public boolean HasactionErrors () {return ValidationAware.hasActionErrors ();} public boolean HasactionMessages () {return ValidationAware.hasActionMessages ();} public boolean HuSerrors () {) {Return validationAware.haserrors ();} public boolean HasFielderRors () {return ValidationAware.hasFielDerRors ();} public void ClearFielderRors () {validationAWeare.ClearfielDerRors ();} public void ClearActionerRors () {ValidationAWe.CLEARACT {validationAware.cLearMessages ();} public void clearErrors () {validationAare.ClearErrors ();} public void ClearErrorsAndMessages () {validationAware.ClearErrorRorSandMessages ();} public void Validate () {} @OverRidEpublic Object () super.clone ();} public void pausa (resultado de cadena) {} textProvider privado getTextProvider () {if (textProvider == null) {textProviderFactory tpf = new TextProviderFactory (); if (Container! = Null) {Contener.inject (TPF);} TextProvider esto);} return textProvider;}@injectPublic void setContainer (contenedor contenedor) {this.container = contenedor;} Puede ver que hay muchos métodos, pero obviamente vemos que hay un método que conocemos muy bien, validate () y la verificación de datos. A través de este método, podemos indicar al iniciar sesión, el nombre de usuario y la contraseña están vacíos u otros ...
Ahora dé un ejemplo simple: cuando el nombre de usuario y la contraseña estén vacíos, déle al cliente un mensaje amigable.
Las siguientes son dos formas de explicar la función de verificación de datos de los puntales 2.
1. Verificación del método de codificación
1) La acción debe ser heredada de ActionSupport
2) Escriba un método público void validatexxx () para que se verifique un método de procesamiento de solicitudes y realice una verificación de datos de formulario dentro del método.
3) También puede escribir el método public Void Validate () para todos los métodos de procesamiento de solicitudes.
4) En el método de verificación, puede agregar el mensaje de error de verificación de campo a través del método addfielderror ().
5) Cuando la verificación falla, el marco de Struts saltará automáticamente a la página de resultados con la entrada de nombre. En la página de falla de verificación, puede usar <S: Fielderror/> para mostrar mensajes de error
6) Simple y flexible. Pero no es muy reutilizable
Reescribir el método de validar
1. La acción que escribimos generalmente hereda y acciones de apoyo, y las acciones que soportan no solo implementa la interfaz de acción, sino que también implementa la interfaz validable, proporcionando la función de verificación de datos. Definir un método de validación en la interfaz Validatable, anular el método, si se produce un error en el campo de entrada del formulario de verificación, agregue el error al campo Fielderror de la clase ActionPport y luego lo supere a través de la expresión de omnl.
La siguiente es la interfaz de verificación de inicio de sesión del usuario:
<Body> <%-Información de verificación de salida-%> <%-si desea un solo mensaje <S: Fielderror fieldName = "uname"/>-%> <%-<s: value de propiedad = ""/>-%> <div style = "color: rojo"> <s: fielderror/> </div> <s: formulario name = "form1 "pace ="/"Method =" Post "=" Post " Action = "LoginValidateAction"> <S: Div> Ingrese el nombre de usuario: <s: Textfield name = "user.uname"> </s: textfield> </s: div> <s: div> por favor ingrese contraseña: <s: name = "user.upwd">/s: contraseña: divs> <s: enviar valor = "login"> </s: subsit> <s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: s: form formul -%> <s: debug> </s: debug> </body>
Después de que el usuario ingrese los datos, envíelo a LoginValidateAction:
La clase pública LoginValidateAction extiende las acciones de las acciones implementos de la acción {Usuario público de usuario; public Map <String, Object> Map; // El método de verificación funcionará en todas las acciones @Override public void validate () {if (user.getUname (). Longitud () == 0) {addfielderror ("Uname", "El nombre del usuario no puede estar vacío!");} if (user.getUpwd (). longitud () == 0) {addfielderror ("upwd", "¿La contraseña no puede estar vacía!");}} // métodos para manejar la cadena pública de negocios ejecuta () arroja excepción {System.out.println (user.getuname ()); if (user.getUname (). Equals ("admin") && user.getupwd (). Equals ("admin")) {// Let Struts2 Inyect Map Collection Map.put ("uname", user.getuname ()); // Si el login es exitoso, regreso "exitoso" exitoso;};};}/} Entrada de errorreturn; // Esto debe ser entrada}}/*** @return el usuario*/público user getUser () {return user;}/*** @param user el usuario para establecer*/public void setUser (usuario de usuario) {this.user = user;} La clase de LoginValidateAction anterior anula el método Validate, que se ejecutará antes de ejecutar el método Excute. Si después de ejecutar el método, el FileDError de la clase de acción contiene un error de verificación de datos, la solicitud se reenviará a la vista lógica de entrada.
Struts.xml se configura de la siguiente manera:
< name = "Login"> fail.jsp </resultado> <resultado name = "error"> fail.jsp </resultado> </action>
Efectos en el cliente:
Pero, ¿ha notado que cuando se solicita el error, no es el efecto que queremos?
Esto no es lo que queremos, entonces, ¿cómo podemos cambiarlo? De hecho, esto muestra principalmente el estilo de tema Struts2,
Vamos a echar un vistazo de nuevo:
Automáticamente nos agrega estilos. Struts2 proporciona tres temas, AJAX, Simple, XHTML. El valor predeterminado es el tema XHTML. Por supuesto, puede escribir cualquiera de sus propios temas, que llamamos temas personalizados. Los problemas anteriores se pueden resolver configurando
Hay dos formas de resolverlo:
1. Método simple (también práctico, para todas las etiquetas Struts2), agregue la siguiente línea de código en Struts.xml.
<constant name = "struts.ui.theme" value = "simple" />
Significa que todas las páginas usan el tema simple. En este momento, la página que emite no agrega ningún código innecesario, como Tabla TR TD, etc., y podemos editar el estilo de la página como otras páginas de edición.
Echemos un vistazo al formato de solicitud de error
Podemos establecer una etiqueta como esta:
<s: propiedad valor = "errores.uname [0]"/>
Comenta esta etiqueta:
<div style = "color: rojo"> <s: filtederror/> </div>
Pero cuando lo configuramos así, este efecto ocurrirá.
Este efecto es un poco como el indicador cuando generalmente ingresamos errores, y hay otros valores de atributos, por lo que no necesitamos enumerarlos uno por uno.
Marco de verificación con Struts2
Verificación de configuración XML.
Se ejecuta antes de codificar.
1) Para la clase de acción a verificar, escriba un archivo de regla de verificación nombrado: clase de acción name-validation.xml en el mismo paquete.
2) Agregue reglas de verificación al archivo de la regla de verificación: para nombres de dispositivos de verificación específicos, consulte la referencia de Struts2 o la API de Struts2.
a) Verificación de campo: Reglas para verificar cada campo de tipo no instantáneo en la clase de acción.
<Nombre de campo = "Nombre de campo a verificar"> <Field-Validator type = "verificar el nombre de la regla" CICTIRIT = "si es una verificación de ruta corta (predeterminado es falso)"> <param name = "nombre del parámetro para ser utilizado por el verificador"> valor </param> <message> mensaje de solicitación cuando la verificación falla </sessage> </field-validator> <!-también puede agregar otro campo> </campo de verificación-Añadir a las reglas de verificación> <
b) Verificación de no campo: use la expresión de OGNL para la verificación combinatoria para ciertos campos en la clase de acción.
<Validator type = "fieldExpression"> <param name = "fieldName"> pwd </param> <param name = "fieldName"> pwd2 </amam> <param name = "expresion"> <! [cdata [pwd == pwd2]]>> </param> <!-expresión de omnl-> <sessiss> confirmar que la entrada de contraseña y contraseña son inconsistentes <//válido> </validator>
c) Verificación del visitante: se usa principalmente para verificar el campo Tipo personalizado en la clase de acción. (Para el uso del modo basado en el modelo)
i) Use reglas de verificación de visitantes para el campo de tipo personalizado en el archivo de reglas de verificación de la clase de acción.
< Especifique el nombre de contexto para esta verificación del visitante-> <param name = "appendprefix"> true </param> <!-si se puede agregar el prefijo del mensaje de falla de verificación-> <sessage> ussage </sessage> <!-Message prefix-> </field-validator> </field>
ii) Escriba un archivo de regla de verificación para el campo del visitante. El nombre del archivo es: Nombre del tipo de campo del visitante [-Visitor Nombre de contexto de verificación] -Validation.xml. Por ejemplo: el nombre del archivo en este ejemplo es user-usercontext-validation.xml
Nota: Este archivo debe almacenarse en el paquete donde se encuentra el tipo de campo del visitante.
iii) Agregar reglas de verificación para que el campo se verifique en el archivo de regla de verificación de campo del visitante.
También podemos realizar una verificación de datos agregando un archivo de configuración de verificación sin reescribir el método Validate. Este archivo de configuración de verificación completa la verificación del campo Formulario utilizando el dispositivo de verificación existente en Struts2. Aquí, tome el dispositivo de verificación de string requerido como ejemplo. Este dispositivo de verificación es un dispositivo de verificación requerido que especifica que se debe ingresar un cierto campo de formulario.
La siguiente es la forma de escribir loginValidateAction-validation.xml de este archivo de configuración de verificación:
<? Xml versión = "1.0" encoding = "utf-8"?> < type = "requiredString"> <sessage> UserName no se puede vaciar </mensaje> </field-validator> </field> <field name = "upwd"> <field-validator type = "requerido"> <sessage> pasaje no puede estar vacío </sessage> </field-validator> <field-validator type = "stringLengm name = "MinLength"> 6 </param> <sessage> La longitud de pasaje debe estar entre $ {minLength}-$ {maxLength} bits </sessage> </field-validator> </field> </idadators> Nota: Este archivo de configuración de verificación debe cumplir con las siguientes dos reglas:
1. El formato de destino del archivo debe ser el nombre de la clase de acción -validation.xml. Por ejemplo, en este ejemplo, el nombre del archivo es: LoginValidateAction-Validation.xml
2. El archivo debe estar en la misma ruta que el archivo de clase de la clase de acción. En este ejemplo, el archivo está en
El código de la clase LoginValidateAction es el mismo:
La clase pública LoginValidateAction extiende las acciones de las acciones implementos de la acción {Usuario público de usuario; public Map <String, Object> Map; // El método de verificación funcionará en todas las acciones @Override public void validate () {if (user.getUname (). Longitud () == 0) {addfielderror ("Uname", "El nombre del usuario no puede estar vacío!");} if (user.getUpwd (). longitud () == 0) {addfielderror ("upwd", "¿La contraseña no puede estar vacía!");}} // métodos para manejar la cadena pública de negocios ejecuta () arroja excepción {System.out.println (user.getuname ()); if (user.getUname (). Equals ("admin") && user.getupwd (). Equals ("admin")) {// Let Struts2 Inyect Map Collection Map.put ("uname", user.getuname ()); // Si el login es exitoso, regreso "exitoso" exitoso;};};}/} Entrada de errorreturn; // Esto debe ser entrada}}/*** @return el usuario*/público user getUser () {return user;}/*** @param user el usuario para establecer*/public void setUser (usuario de usuario) {this.user = user;}Lo anterior es la función de verificación de datos de Struts 2 y la solución al problema de verificación introducido por el editor. Espero que sea útil para todos. Si tiene alguna pregunta, déjame un mensaje y el editor responderá a todos a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!