Spring AOP Método de anotación personalizada para implementar la explicación de ejemplo de gestión del registro

Hoy sigo implementando AOP. Personalmente, creo que es la forma más flexible y extensible. Tome la gestión de registros como ejemplo, utilizando el formulario de anotación personalizada Spring AOP para implementar la gestión de registros. Sin más preámbulos, comience de inmediato! ! !

Diré de nuevo sobre la configuración.

Qué agregar en ApplicationContext-Mvc.xml

 <MVC: anotación-conducido /> <!-Activar la función de escaneo de componentes, escanear automáticamente los componentes configurados a través de la anotación en el paquete com.gcx y sus subpackages-> <context: component-scan base-package = "com.gcx" /> <!-iniciar el soporte para @Aspectj annotation-> <!-Proxy-Target-class iguales verdadero, qué fuerzas de uso de CHGLIB de CHGLIB. Proxy-Target-Class es falso de forma predeterminada. Si su clase implementa la interfaz, vaya al proxy JDK. Si no, vaya a CGLIB proxy-> <!-Nota: se recomienda utilizar el proxy CGLIB para el modo de beneficio simple. Aunque el proxy dinámico JDK es más rápido que el proxy cglib, su rendimiento no es tan bueno como cglib-> <!-si no escribe proxy-target-class = "true", la oración está bien-> <aop: systemlogasj-auTopproxy proxy-target-class = "true"/> <!-section-> <bean id = "systemlogaspect"> <> <<> <> <> <</</</</bean>

A continuación, comience a escribir el código.

Crear una entidad de registro

 clase pública Systemlog {ID de cadena privada; Descripción de la cadena privada; Método de cadena privada; Long Logtype privado; Solicitud de cadena privada; Cadena privada ExceptionCode; ExceptionDetail de cadena privada; parámetros de cadena privada; cadena privada createby; fecha privada creada; public String getId () {return id; } public void setid (ID de cadena) {this.id = id == null? nulo: id.trim (); } public String getDescription () {return Descripción; } public void setDescription (String Descripción) {this.description = Descripción == NULL? NULL: Descripción.trim (); } public String getMethod () {Método de retorno; } public void setMethod (método de cadena) {this.method = método == null? nulo: método.trim (); } public Long getLogType () {return logType; } public void setLogType (long logType) {this.logType = logType; } public String getRequestip () {return requestIP; } public void setRequestip (String requestip) {this.requestip = requestip == null? nulo: requestip.trim (); } public String getExceptionCode () {return ExceptionCode; } public void setExceptionCode (String ExceptionCode) {this.ExceptionCode = ExceptionCode == NULL? nulo: excepcioncode.trim (); } public String getExceptionDetail () {return exceptionDetail; } public void setExceptionDetail (String ExceptionDetail) {this.ExceptionDetail = ExceptionDetail == NULL? nulo: excepcionDetail.trim (); } public String getParams () {return Params; } public void setParams (String Params) {this.params = params == null? nulo: params.trim (); } public String getCreateBy () {return createBy; } public void setCreateBy (string createBy) {this.createBy = createBy == null? null: createBy.trim (); } fecha pública GetCreateDate () {return creatate; } public void setCreatedate (date creatateate) {this.createdate = creatateate; }}

Escribir una interfaz DAO

 paquete com.gcx.dao; import com.gcx.entity.systemlog; interfaz pública systemlogMapper {int deletyprimarykey (ID de cadena); int Insert (Systemlog Record); int Insertselective (Systemlog Record); Systemlog SelectByPrimaryKey (ID de cadena); int updateByPrimaryKey (Systemlog Record);}

Escribir una capa de servicio

 paquete com.gcx.service; import com.gcx.entity.systemlog; public interfaz SystemlogService {int deletesystemlog (ID de cadena); int Insert (Systemlog Record); int InsertTest (Systemlog Record); Systemlog selectSystemlog (ID de cadena); int UpdateSystemlog (Systemlog Record);}

Escribir la clase de implementación del servicio ServiceImpl

 paquete com.gcx.service.impl; import javax.annotation.resource; import org.springframework.stereotype.service; import com.gcx.annotation.log; import com.gcx.dao.systemlogMapper; import com.gcx.entity.systemlog; import com.gcx.service.systemlogService; @Service ("SystemlogService") clase pública SystemlogServiceImpl implementa SystemlogService {@Resource SystemlogMapper SystemLogMapper; @Override public int DeleteSystemlog (ID de cadena) {return SystemlogMapper.DeleteByPrimaryKey (id); } @Override public int Insert (Systemlog Record) {return SystemlogMapper.insertSelective (registro); } @Override public systemlog selectSystemlog (ID de cadena) {return SystemLogMapper.SelectByPrimaryKey (id); } @Override public int UpdateSystemlog (Systemlog Record) {return SystemlogMapper.UpdateByPrimaryKeySelective (registro); } @Override public int InsertTest (Systemlog Record) {return SystemLogMapper.insert (registro); }}

Aquí el programa básico está terminado

A continuación se muestra la anotación personalizada

 paquete com.gcx.annotation; import java.lang.annotation.*; @target ({elementtype.parameter, elementtype.method}) @retention (retentionPolicy.runtime) @documented public @interface log { / ** el tipo de operación que se realizará, como: agregar operación ** / public string operationType () predeterminado ";" ";" "; / ** La operación específica que se realizará, como: Agregar usuario **/ public String operationName () predeterminado "";}

Escribe el corte a continuación

 paquete com.gcx.annotation; import java.lang.reflect.method; import java.util.date; import java.util.uuid; import javax.annotation.resource; import javax.servlet.http.httttpServletRequest; import javax.servlet.http.httpsession; org. org.spectj.lang.annotation.aspect; import org.aspectj.lang.annotation.before; import org.aspectj.lang.annotation.pointcut; import org.slf4j.logger; import og.slf4j.loggeryory; import og.springFrameWork.stereotype.component; com.gcx.entity.user; import com.gcx.service.systemlogService; import com.gcx.util.jsonutil;/*** @author yang jian* @e-correo electrónico: correo electrónico* @version creado tiempo: 2015-10-19 4:29:05 pm* @desc-cut class*/ @asco @componentpsicpualslogeSlogeSpect registra la base de datos @Resource // Utilizo la anotación de recursos aquí, generalmente usando @aUtowired. Sus diferencias. Si tengo tiempo, escribiré SystemlogService SystemlogService privado en el blog posterior; Private static final logger logger = loggerFactory.getLogger (SystemLogaspect. Class); // Controlador Capa Tangent Point @PointCut ("Ejecution (* com.gcx.controller ..*.* (..))") public void controleraSpect () {}/*** pre-notificación se usa para interceptar la capa del controlador para registrar las operaciones del usuario** @param unión de un punto de unión Tangent Point*/@before ("Controlyraspect ()") ")") { System.out.println("====================================================================================================== ================================================================ ================================================================ ================================================================ ================================================================ ================================================================ ================================================================= System.out.println("========================================================================================== System.currentTimeMillis(); try { ((Procedimiento de piso de unión). System.out.println ("========================================================================================== System.CurrentTimemillis (); If (Logger.isinfo () (isLiSinfo () () logger.info ("Around" + unkenpoint + " /TUSE TIME:" + (end - inicio) + "MS con excepción:" + E.getMessage ()); HttpservletRequest request = ((ServLetRequestAtTributes) Solicitude. = nuevo usuario (); Class.forname (TargetName); método.getAnnotation (log.class) .operationType (); System.out.println ("Método de solicitud:" + (unePoint.GetTarget (). System.out.println ("Solicitar IP:" + IP); log.setMethod ((unkePoint.getTarget (). getClass (). log.setparams (null); logger.error ("== excepción de notificación =="); Ejecutar la notificación del controlador post-retorno ========); doafterThrowing (unión unePoint, showable e) { /*httpservletRequest request = ((ServLetRequestAtTributes) requestContexTholder.getRequestTibutes ()). getRequest () // Obtener una cadena ip = request.getRemoteaddr (); unkePoint.getArgs (). Longitud> 0) {for (int i = 0; i <unkePoint.getArgs (). unket.getSignature (). GetName (); Method.getParametTypes (); System.out.println ("================= Notificación de excepción start======================================================================================= ==================================================================================================================================================== ==================================================================================================================================================== ==================================================================================================================================================== System.out.println ("Información de excepción:" + E.getMessage ()); System.out.println ("Requester:" + user.getName ()); log.setId (uuid.randomuuid (). toString ()); log.setMethod ((unkePoint.getTarget (). GetClass (). GetName () + ". SystemlogService.insert (log); ex.getMessage ()); E.GetClass (). GetName (), E.GetClass (). GetName (), Params);

He escrito mucho aquí, incluyendo pre-nota, notificación envolvente, post-nota, notificación de excepción y notificación posterior a la comida. Está bien si no lo escribo todo en nuestra escritura real. Estoy acostumbrado a escribir la lógica de registro en el post-log. Veo que algunas de las notificaciones previas a la registro también se incluyen en las notificaciones previas a la registro en Internet, pero creo que es mejor escribirlo en las notificaciones posteriores a la sesión.

¡Comencemos a agregar anotaciones personalizadas al controlador! !

 paquete com.gcx.controller; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.stereotype.controller; import org.springframework.web.bind.annotation.requestmapping; import com.gcx.annotation.log; import com.gcx.service.userservice;@controler@requestmapping ("UserController") Clase pública UserController {@aUtowired private UserService UserSerService; @RequestMapping ("testaop") @log (operationType = "Agregar operación:", operationName = "Agregar usuario") public void testaop (String UserName, String Password) {UserService.Adduser (username, contraseña); }}

Escribe la clase de prueba a continuación

 @Test public void testaop1 () {// iniciar el contenedor de primavera ApplicationContext ctx = new classpathxmlaPlaPlicationContext (new String [] {"classpath: applicationContext-Mvc.xml", "classpath: applicationContext-DataSource.xml"}); // Obtener servicio o componente del controlador UserController UserController = (UserController) CTX.GetBean ("UserController"); UserController.testaop ("Zhangsan", "123456"); }

Datos de la base de datos:

Originalmente quería escribir dos puntos tangentes, uno es la capa de servicio y la otra es la capa del controlador. La capa de servicio se utiliza para registrar información de excepción, mientras que la capa del controlador se utiliza para grabar funciones. El resultado de ejecución es el siguiente.

Si hace esto, no sé si la eficiencia de la operación es buena en el proyecto real. ¡Vea el Daniu del blog aquí para dar algunas sugerencias! !

La explicación de ejemplo anterior del método Spring AOP Custom Annotation para implementar la administración de registros es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.