1. Prefacio
1.1. ¿Qué es la verificación de entrada? ¿Por qué necesito ingresar a la verificación?
En el artículo anterior, aprendimos sobre la conversión de tipo de datos. Mencionamos dos métodos de procesamiento de datos de la capa de presentación. También mencionamos que los datos de entrada del usuario deben ser la conversión de tipo para obtener los datos que queremos. Entonces, ¿cómo determinamos que los datos después de la conversión de tipo son los datos que queremos? Es un poco transversal aquí. Puede pensarlo así: un hombre adulto tiene 18 años y desea obtener los datos de 18 ahora, pero el usuario entró 32 y también es correcto convertirlo a través del tipo, pero los datos no son lo que desea. ¿Qué debemos hacer en este momento? Entonces, la verificación de entrada es útil aquí.
La relación entre la conversión de tipo y la verificación de entrada es: la conversión de tipo es el requisito previo para la verificación de entrada. Si ambas conversiones de tipo son incorrectas, entonces no hay necesidad de realizar una verificación de entrada. Pero a menudo tipo la conversión y la verificación de entrada se realizan al mismo tiempo.
Hay dos tipos de verificación de entrada:
1. Verificación del cliente;
2. Verificación del lado del servidor. Lo que explicamos principalmente aquí es la verificación del lado del servidor (reescribe el método Validatexxx y la verificación del archivo de configuración XML)
1.2. Proceso de verificación del método de reescritura Validatexxx
1. El convertidor de tipo es responsable de la conversión de tipo de los parámetros de solicitud de la cadena y establece estos valores en los valores de propiedad de la acción.
2. Puede ocurrir una excepción durante la ejecución de la conversión de tipo. Si se produce una excepción, la información de excepción se guardará automáticamente en ActionContext. El Interceptor ConversorerRor es responsable de encapsularlo en un fildeador.
3. Llame al método Validatexxx () a través de la reflexión, donde xxx es el nombre del método correspondiente a la lógica de procesamiento que procesará la solicitud del usuario.
4. Llame al método de validación de la clase de acción
5. Si los pasos anteriores no muestran un fildeador, se llamará al método de procesamiento para procesar las solicitudes de los usuarios en la acción. Si aparece un Fielderror, el sistema se transferirá a la vista especificada en la vista lógica de entrada.
2. Verificación de entrada
2.1. Hay dos formas de ingresar a la verificación aquí:
1. Reescribe el método Validate o personalice el método Validatexxx (donde xxx es el nombre que define, el método se ejecutará primero y el método Validate se ejecutará)
2. Cree un nuevo XML para la verificación
2.2. Reescribir el método de validar
En el marco MVC, se proporciona una parte de verificación de datos estandarizada. Struts2 proporciona un método de validar aquí. Podemos reescribir el método Validar para realizar la verificación de entrada. Sin embargo, hay dos puntos que saber sobre la reescritura del método Validate: 1. El método Validate se ejecutará antes del método de ejecución; 2. El método Validate ejecutará reglas de verificación para todas las acciones. Para distinguir una determinada acción, podemos usar el método Validatexxx.
Nota: Los siguientes ejemplos son ejemplos de conversión de tipo local y validación de entrada.
Ejemplo de verificación de registro simple:
Cree un nuevo usuario de clase de entidad:
Usuario
Crear una nueva vista: registrar.jsp
<%@ page lenguaje = "java" contentType = "text/html; charset = utf-8" PageEncoding = "utf-8"%> <%@ taglib uri = "/struts-tags" prefix = "s"%> <! Doctype html público "-// w3c // dtd html 4.01 transitional // "http://www.w3.org/tr/html4/loose.dtd"> podet Action = "Register_test"> User: <input type = "text" name = "user"> <br/> contraseña: <input type = "contraseña" name = "user"> <br/> contraseña: <input type = "contraseña" name = "user"> <BR/> <input type = "Subt" Value = "Subt"> </form> </body> </ html>
Cree una nueva clase de registro de registro para heredar ActionSupport
paquete com.validatexxx; import com.opensymphony.xwork2.ActionSupport; // Rewrite Validate () y Validatexxx Métodos especificados para la verificación/ * * en Struts.xml, el método ValidateTeTest () se llamará primero, y luego se llama el método de prueba después de llamar al método Validate * */Public Clase Registring ExtendsUpport {User de usuario privado; Usuario público getUser () {Return User; } public void setUser (usuario de usuario) {this.user = user; } // 2 @Override public void validate () {System.out.println ("Reescribir el método Validate"); if (null == user.getPassword () || "" .equals (user.getPassword ()) || null == user.getRepassword () || "" .equals (user.getRepassword ())) {this.addfielderror ("repassword", "Repassword debería ser la misma contraseña"); devolver; } if (! user.getPassword (). Equals (user.getRepassword ())) {// Cuando los datos existen en Fielderror, el servidor saltará automáticamente a la vista lógica de la entrada this.addfielderror ("Repassword", "Repassword debe ser la misma contraseña"); }} // 1 public void ValidateTest () {System.out.println ("Método de verificación personalizado: ValidateTest"); } // 3 public String test () {System.out.println ("Test: Method"); devolver el éxito; }}Nota: La propiedad aquí es usuario, por lo que el nombre del parámetro de su página JSP debe escribirse como el nombre del usuario de la instancia, y luego también debe crear un convertidor de tipo para devolver una clase llena de datos
Cree un nuevo Struts.xml y guárdelo en Web-INF/Classes/Struts.xml
Nota: El método aquí debe ser definido por usted después de su método valudatexxxx (). Aquí está la prueba. Si usa *, Structs2 también debe configurar el método estricto-Invocation = "False". Se dice que debido a que la versión es demasiado alta, su seguridad se ha incrementado y todo debe agregarse para usar *
Cree una nueva clase de UsertyPeconverter para heredar StrutStyPeconverter (cree un convertidor de tipo)
paquete com.validatexxx; import java.util.map; import org.apache.struts2.util.strutstypeconverter; // clase de conversión de tipo clase public class usertypeconverter extiende strutstypeconverter {@override públicos objeto convertirfomstring (map arg0, string [] arg1, class arg2) { System.out.println ("UsertyPeconverter: ¡Tipo de conversión!"); Usuario user = nuevo usuario (); user.setUsername (arg1 [0]); user.setPassword (arg1 [1]); user.setRepassword (arg1 [2]); devolver el usuario; } @Override public String ConvertToString (map arg0, object arg1) {user u = (user) arg1; return u.getusername ()+"!"; }}Nota: Después de que se cree el convertidor de este tipo, debe crear una nueva Conversión de RegistroCaction.Properties y colocarlo en el mismo directorio.
El contenido de este archivo es:
El primero es el nombre de la propiedad que está en Registray, seguido de la ruta específica al convertidor de tipo.
Crear una nueva vista de éxito: Success.jsp
éxito.jsp
Crear una nueva vista de error: input.jsp
input.jsp
El efecto de la ejecución exitosa del código es el siguiente:
Registro.jsp página
La página que saltó con éxito es: Success.jsp
Los resultados de la prueba de la consola son:
Los datos saltan a UsertyPeconverter para la conversión de tipo, luego salta a registro de registro, ejecuta ValidateTest Method (), valida y luego devuelve el éxito, y luego ejecuta la vista de resultados.
Veamos el orden en que falla el código:
Registro.jsp página
página input.jsp
Efecto de prueba de consola:
En el método Validate, el código del autor es: this.addfielderror (). Como se mencionó anteriormente, si se agrega un error, el servidor nos ayudará automáticamente a saltar a la interfaz incorrecta. Devolverá la entrada y la entrada está configurada en Struts.xml y volverá a la interfaz input.jsp.
2.3. Crear un nuevo XML para la verificación de entrada
Cree una nueva interfaz de vista: test.jsp
<%@ page lenguaje = "java" contentType = "text/html; charset = utf-8" PageEncoding = "utf-8"%> <%@ taglib uri = "/struts-tags" prefix = "s"%> <! Doctype html público "-// w3c // dtd html 4.01 transitional // "http://www.w3.org/tr/html4/loose.dtd"><html><head><meta http-equiv =" content-type "content =" text/html; charset = utf-8 "> <title> Use la verificación XML </shed> </head> <body> <s Action =" <s: textfield name = "name" etiqueta = "name" size = "20" /> <s: textfield name = "edad" etiqueta = "edad" size = "20" /> <s: enviar name = "envío" etiqueta = "enviar" align = "centro" /> < /s: form> </body> </html>
Cree una nueva clase de empleados para heredar acciones.
Esta clase utiliza el método de validación de anulación y la configuración XML, podemos elegir uno de ellos para la verificación
paquete com.validatexxx; import com.opensymphony.xwork2.ActionSupport; // Use el método Validate () para verificar, ¡esta es la verificación del lado del servidor! El empleado de clase pública extiende ActionSupport {Nombre de cadena privada; edad privada int; public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public int getAge () {return Age; } public void setAge (int Age) {this.age = edad; } // El segundo paso ejecuta este método public String Execute () {System.out.println ("Ejecutar:"+this.age); devolver el éxito; }/* Verificación utilizando el lado del servidor: Reescribe el método Validate (); // El primer paso es ejecutar el método // Reescribir el método Validate tiene una falla: cada vez que usa el método Validar para verificar, causando grandes desperdicios de recursos. public void validate () {system.out.println ("validar"); if (name == null || name.trim (). Equals ("")) {// Al agregar datos a este método, el servidor devolverá la entrada y luego saltará a la página input.jsp. addfielderror ("nombre", "se requiere el nombre"); } if (edad <28 || edad> 65) {addfielderror ("edad", "edad debe estar entre 28 y 65"); }}*/}Configurar en Struts.xml:
El éxito.jsp e input.jsp aquí todavía usa lo anterior.
Después de eso, necesitamos crear un nuevo empleado-validación.xml y colocar la ruta en el mismo directorio que el empleado. Nota: -Validation.xml es fijo y sin cambios.
Los contenidos son:
<? xml versión = "1.0" encoding = "utf-8"?> <! DocType Validators public "-// Apache Struts // Xwork Validator 1.0.3 // en" "http://struts.apache.org/dtds/xwork-validator-1.0.3.dtd"> <calvalorators> <camed = "name" <nombre "<nombre" <nombre " <Message> Se requiere el nombre. </sessage> </field-validator> </field> <field name = "edad"> <field-validator type = "int"> <param name = "min"> 29 </amam> <param name = "max"> 64 </amam> <sageS> La edad debe estar entre 28 y 65 </sessage> </field-validator> </cield> </alvalicators>
Punto clave: el límite DTD de este archivo debe ser, de lo contrario el error de retorno:
Error DefaultDisPatcherErrorHandler Excepción se produjo durante la solicitud de procesamiento: [Libro de conexión de conexión: Connect - [Ubicación desconocida], NULL]
A continuación, usamos http: // localhost: 8080/learstruts2/validatejsp/test.jsp para el acceso.
Probado con éxito:
Interfaz test.jsp:
éxito.jsp
Ejemplo de falla de prueba:
interfaz input.jsp:
El ejemplo de la ilustración es correcto.
De hecho, existen múltiples validadores incorporados en Struts2: Validador requerido, Validador de cadena requerido, Validador Integer, Validador de fecha, Validador de Expresión, Validador de Longitud de Carácter, Validador de expresión regular, etc. Si es necesario, el autor explicará este uno por uno.
Lo anterior es una explicación detallada del tutorial de verificación de entrada de datos STRUTS2 que le presenta el editor. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!