Implementación de un monitoreo lento de interfaces externas basado en Spring AOP
AOP es el núcleo de Spring. Spring no solo integra múltiples marcos basados en AOP, sino que también lo expone a los usuarios comunes de una forma muy conveniente. En el pasado, AOP no se usaba mucho principalmente porque era. insertado de manera transversal en el proceso principal, nos preocupa que el código del proceso principal no sea lo suficientemente claro para localizar el problema y no sea lo suficientemente conveniente. En la segunda fase del proyecto de facturación, necesitamos una función que lo sea. muy adecuado para usar AOP, que es para registrar el tiempo que consume la interfaz externa y la interfaz externa llamada, esta demanda proviene principalmente de la depuración conjunta del primer período de facturación. Lo suficientemente fluido. Esto requiere observar el tiempo de llamada de cada interfaz para determinar quién tiene el problema.
El centro de facturación es todo Hay muchas interfaces de este tipo en los enlaces intermedios del sistema backend que interactúan con otras. Sería engorroso agregar registros de tiempo antes y después de llamar a cada interfaz, lo que también afectaría la belleza del código del proceso principal. Por lo tanto, una forma más elegante es usar AOP sin invadir el código original. Se puede agregar monitoreo de llamadas a la interfaz y se puede eliminar fácilmente cuando no sea necesario. Lo probé hoy y parece funcionar bien. Aquí están los pasos de implementación
)Introducción de dependencias de paquetes
< p. > Este proyecto está construido en base a maven, por lo que es más conveniente agregar dependencias de paquetes. Las bibliotecas de dependencia de AOP que necesito son las siguientes tres[x]
.
< dependencia>
< /dependencia>
) más el archivo de configuración Spring de AOP
facturación spring aop xml :
[x]
xmlns: xsi= instancia xmlns:aop= xmlns:tx= xsi:schemaLocation= beans xsd aop xsd tx xsd > Expresión= ejecución(* producto E *** PriceService *()) /> expresión= ejecución(* producto E *** ProductoServicio *()) /> Expresión= ejecución(* alibaba bss pc server comunicación remota IAuthorizeControllerService *()) /> Expresión= ejecución(* seleccionar IOpenApiOrderItemService *()) /> expresión= ejecución(* seleccionar IOpenApiBillingCollectService *()) /> iceService expresión= ejecución(* bu api de facturación factura IOpenApiInvoiceService *()) /> expresión= ejecución(* llect IOpenApiChargeProductInfoService *()) />
xmlns :xsi= instancia xmlns:aop= xmlns:tx= xsi:schemaLocation= beans xsd aop xsd tx xsd > < aop:config > t Expresión= ejecución(* producto E *** PriceService *()) /> expresión= ejecución(* producto E *** ProductService *()) /> Expresión= ejecución(* alibaba bss pc server remotamente IAuthorizeControllerService *()) /> Expresión= ejecución(* seleccione IOpenApiOrderItemService *()) /> expresión= ejecución(* seleccione IOpenApiBillingCollectService *()) /> < aop:pointcut id= IOpenApiInvoiceService expresión= ejecución(* bu factura api de facturación IOpenApiInvoiceService *()) /> expresión= ejecución(* llect IOpenApiChargeProductInfoService *()) /> < aop:método alrededor= logExecute Punto de corte de tiempo ref= IOpenApiInvoiceService />
Completé el acceso AOP según la configuración. La ventaja de esto es que no requiere ninguna inmersión en el código del proceso principal original y. es más fácil de mover Además de la interceptación de este AOP, este código configura principalmente puntos de corte y consejos
) Escribir consejos de monitoreo que requieren mucho tiempo
OpenApiLogAspect:
[java]
p>
clase pública OpenApiLogAspect {
registrador LoggerService estático privado = LoggerFactory getLogger(clase OpenApiLogAspect);
objeto público; logExecuteTime(ProceedingJoinPoint joinPoint) lanza Throwable{
Fecha de inicio = nueva Fecha();
try{
return joinPoint proceder(joinPoint getArgs()); /p>
}catch(Error de excepción){
lanzar err;
}finalmente{
Fecha de finalización = nueva fecha(); p>
( OpenApiExecuteTime: +joinPoint getSignature() getName()+ toma +(end getTime() start getTime())+ ms
}
} <); /p>
}
clase pública OpenApiLogAspect {
registrador LoggerService estático privado = LoggerFactory getLogger(clase OpenApiLogAspect);
objeto público logExecuteTime(ProceedingJoinPoint joinPoint); ) lanza Throwable{
Fecha de inicio = nueva Fecha();
prueba{
return joinPoint proceder(joinPoint getArgs()); p>}catch(Error de excepción){
lanzar error;
}finalmente{
Fecha de finalización = nueva fecha(); >( OpenApiExecuteTime: +joinPoint getSignature() getName()+ toma +(end getTime() start getTime())+ ms
}
<);p> }
}
Este código se basa en el método around para interceptar llamadas a la interfaz, agregar registros de tiempo antes y después de la llamada real y, finalmente, imprimir la diferencia horaria en el log, donde joinPoint procede (joinPoint getArgs()); es una llamada a la interfaz real
) hace que el monitoreo sea configurable
Esta función solo se usará en la fase de depuración y no debe ejecutarse en el entorno de producción. Por lo tanto, es necesario configurar si desea monitorear la interfaz. La implementación de esta configuración es muy simple, solo necesita decidir si desea agregar el archivo de configuración de aop spring al contenedor. el siguiente código para el contenedor total applicationContext xml vm
# if(${monitor_openapi_showTime}== true )
#end
Compilación Durante el proceso de empaquetado, la variable monitor_openapi_showTime se utilizará para determinar si se introduce el resorte de facturación aop xml
) El efecto operativo
Cuando la supervisión está activada, si se produce una llamada de interfaz, se puede ver en el registro. Registrado de la siguiente manera
: : [OpenApiLogAspect java: ] [bu billing framework aop OpenApiLogAspect] INFORMACIÓN marco de facturación bu aop OpenApiLogAspect :: OpenApiExecuteTime:installOrderItem toma ms
: : [OpenApiLogAspect java: ] [marco de facturación bu aop OpenApiLogAspect] INFORMACIÓN marco de facturación bu aop OpenApiLogAspect :: OpenApiExecuteTime:installOrderItem toma ms lishixinzhi/Article/ programa/Java/ky/201311/28361