Este artículo presenta la escritura de un AOP basado en Spring Boot y JDK8, combinando anotaciones personalizadas para lograr la verificación de parámetros de interfaz común.
razón
Actualmente, el método de verificación de parámetros comúnmente utilizado es agregar anotaciones en la clase de entidad, pero para diferentes métodos, las reglas de verificación aplicadas también son diferentes. Por ejemplo, hay una entidad Accountvo:
public class Accountvo {Nombre de cadena privada; // Nombra la edad del entero privado; // Edad}Supongamos que hay un negocio: cuando un usuario se registra, él o ella necesita completar su nombre, y cuando un usuario inicia sesión, solo necesita completar su nombre. Entonces es obviamente inapropiado agregar reglas de verificación a las clases de entidad.
Por lo tanto, siempre he querido implementar una verificación de parámetros a nivel de método. Los diferentes métodos pueden aplicar diferentes reglas de verificación para los mismos parámetros de entidad, lo que dio a luz a esta herramienta y se ha utilizado en el trabajo diario durante mucho tiempo.
introducir
Echemos un vistazo a cómo usarlo primero:
@ServicePublic Class TestImpl implementa ItestService {@Override @Check ({"Nombre", "Age"}) public void testValid (Accountvo Vo) {// ...}}La anotación @Check en el método indica que las propiedades de nombre y edad en el parámetro Accountvo no pueden estar vacías. Además de la verificación no vacía, también respalda el juicio del tamaño y la verificación de la igualdad:
@Check ({"id> = 8", "Nombre! = Aaa", "Título <10"})El mensaje de error predeterminado devuelve los campos, las causas de error y los métodos llamados, como:
UpdateUserId no debe nulo mientras llama a TestValidid Must> = 8 mientras llama a TestValidName debe! = AAA al llamar a TestValid
También se admite la información de retorno de errores personalizados:
@Check ({"Título <= 8: El número de caracteres de título no excede los 8 caracteres, incluidos los signos de puntuación"}) public void testValid (testpo po) {// ...}Simplemente agregue: después de la regla de verificación y escriba información personalizada, que reemplazará el mensaje de error predeterminado.
PS: El principio central es obtener el valor del campo en la entidad del parámetro a través de la reflexión, y luego verificarlo de acuerdo con las reglas. Por lo tanto, actualmente solo se admiten métodos que contienen un parámetro, y los parámetros no pueden ser del tipo básico.
usar
Cómo usar AOP en Spring-Boot No entraré en detalles aquí, y presentaré principalmente el código central en AOP.
Dependencias maven
Además de las dependencias de Boot Spring, las dependencias de terceros requeridas no son dependencias básicas, y puede elegir de acuerdo con sus hábitos personales:
< <Versión> 1.7.25 </versión> </pendency>
Anotaciones personalizadas
import java.lang.annotation.ElementType; import java.lang.annotation.retention; import java.lang.annotation.target; import static java.lang.annotation.retentionpolicy.runtime;/*** Annotación de verificación de parámetros* Creado por Cipher en 2017/9/20. */@Target ({elementtype.type, elementtype.method})@retención (runtime) public @interface check {// reglas de verificación de campo, formato: nombre de campo + reglas de verificación + mensaje de error + mensaje de error, por ejemplo: id <10: id debe ser menor que 10 cadenas [] valor ();};Código central
Al interceptar el método de interfaz con la anotación @Check, realice la verificación de parámetros antes de ejecutar el método. Si hay un mensaje de error, se devolverá directamente:
@Around (value = "@com.cipher.checker.check") // Aquí debe cambiar a la ruta de la revisión de objeto público de anotación personalizada (el punto de punto de procedimiento) lanza lando {objeto obj; // Cadena de verificación de parámetros msg = doccheck (punto); if (! stringUtils.isEmpty (msg)) {// Aquí puede devolver la clase de retorno encapsulada tirar nueva ilegalArgumentException (msg); } obj = Point.proced (); regresar obj;}El método de verificación de núcleo En el método de docheck, el principio principal es obtener el nombre de campo y las reglas de verificación especificadas en la anotación, obtener el valor del campo correspondiente en la entidad de parámetros a través de la reflexión y luego realizar verificación:
/*** Verificación de parámetros** @param Point procedimientoJoinpoint* @return Mensaje de error*/private string docheck (procedingjoinpoint punto) {// get método valor de valor de parámetro [] argumentos = punto.getArgs (); // Get Method Method Method = getMethod (punto); String MethodInfo = StringUtils.isEmpty (método.getName ())? "": "mientras llama" + método.getName (); Cadena msg = ""; if (isCheck (método, argumentos)) {check annotation = método.getAnnotation (check.class); String [] Fields = annotation.Value (); Objeto vo = argumentos [0]; if (vo == null) {msg = "param no puede ser nulo"; } else {para (campo de cadena: campos) {// Poner campo FieldInfo Info = resolveField (Field, MethodInfo); // Obtener el valor del valor del objeto de campo = ReflectionUtil.InvoKeGetter (vo, info.field); // Ejecutar la regla de verificación boolean isValid = info.optenum.fun.apply (valor, info.operatornum); msg = isValid? Msg: info.innermsg; }}} return msg;}Puedes ver que la lógica principal es:
Campos de análisis -> Obtener el valor de los campos -> Ejecutar reglas de verificación
Una clase de enumeración se mantiene internamente, y las operaciones de verificación relevantes se especifican en ella:
/** * Operation enum */enum operador {/** * mayor que */greater_than (">", checkparamAspect :: isGreaterThan),/** * mayor que o igual a */greater_than_equal ("> =", checkParameSpect :: isGreaterThanequal),/** * menos que */menos_than ("", "," / *** Menos que o igual a* / menos_than_equal ("<=", checkParamAspect :: islessthanequal), / *** no es igual a* / not_equal ("! =", CheckParamAspect :: isnotequal), / *** no vacío* / nohnlull ("no null", checkParamassect :: isnotnull); valor de cadena privada; bifunción privada <objeto, cadena, boolean> diversión; Operador (valor de cadena, bifunción <objeto, string, boolean> divertir) {this.value = valor; this.fun = diversión; }} Debido a las razones de espacio, no expandiré todos los códigos uno por uno. Los amigos interesados pueden obtener todos los códigos de origen en la siguiente dirección: Ciphermagic/Java-Learn/Sandbox/Checker
HACER
por fin
Gracias por tu lectura. Amigos a los que les gusta puede gustarle en Github. Si tiene alguna pregunta o sugerencia, deje un mensaje a continuación y espere su respuesta.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.