Hoje continuo implementando a AOP. Pessoalmente, acho que é a maneira mais flexível e extensível. Tome o gerenciamento de log como exemplo, usando o formulário de anotação personalizado da Spring AOP para implementar o gerenciamento de logs. Sem mais delongas, comece imediatamente! ! !
Vou dizer novamente sobre a configuração.
O que adicionar em ApplicationContext-Mvc.xml
<mvc: anotação orientada /> <!-Ative a função de varredura de componentes, digitalize automaticamente os componentes configurados por anotação em pacote com.gcx e seus subpackagens-> <contexto: component-scan-package = "com.gcx" /> <!-suporta para @aspectj annatation-> <! A classe proxy-alvo é falsa por padrão. Se sua classe implementar a interface, vá para o proxy JDK. Caso contrário, vá para CGLIB Proxy-> <!-Nota: é recomendável usar o proxy do CGLIB para o modo de lucro simples. Embora o proxy dinâmico do JDK seja mais rápido que o proxy do CGLIB, seu desempenho não é tão bom quanto o cglib-> <!-se você não escrever proxy-alget-class = "true", a frase está OK-> <AoP: AspectJ-AutopProxy proxy-target = ""/> <!-Seção-
Em seguida, comece a escrever o código.
Crie uma entidade de log
classe pública Systemlog {private String ID; Descrição de String Private; Método Private String; Private Long Logtype; Private String RequestiP; ExceptionCode String Private; Private String ExceptionDetail; params de sequência privada; String privada Createby; data privada criada; public string getId () {return id; } public void setId (string id) {this.id = id == null? null: id.trim (); } public string getDescription () {return description; } public void SetDescription (String Description) {this.Description = Descrição == NULL? nulo: description.Trim (); } public String getMethod () {Método de retorno; } public void setMethod (método da string) {this.method = método == null? null: métod.Trim (); } public long getLogtype () {return logtype; } public void setLogtype (LONGTYPE) {this.logtype = logType; } public String getRequestip () {return requestIPIP; } public void setRequestip (string requestIP) {this.requestip = requestIP == null? null: requestiP.trim (); } public string getExceptionCode () {return ExceptionCode; } public void setExceptionCode (String ExceptionCode) {this.ExceptionCode = ExceptionCode == NULL? NULL: ExceptionCode.Trim (); } public string getExceptionDetail () {return ExceptionDetail; } public void setExceptionDetail (String ExceptionDetail) {this.ExceptionDetail = ExceptionDetail == NULL? null: excepçãoDetail.Trim (); } public string getParams () {return params; } public void setParams (String params) {this.params = params == null? null: params.trim (); } public string getCreateBy () {return createby; } public void SetCreateBy (String createby) {this.Createby = cremeby == null? null: cremeby.trim (); } public data getCreatedate () {return criatedate; } public void setCreatedate (data criado) {this.createdate = criatedate; }}Escrevendo uma interface Dao
pacote com.gcx.dao; importar com.gcx.entity.systemlog; interface pública SystemLogMapper {int deLeteByPrimaryKey (string id); int insert (registro do sistema); int insertSelective (registro do sistema); SystemLog SelectByPrimaryKey (String ID); int updateByPrimaryKey (Systemlog Record);}Escrevendo uma camada de serviço
pacote com.gcx.service; import com.gcx.entity.systemlog; interface pública SystemLogService {int DeLetesystemLog (string id); int insert (registro do sistema); int inserttest (registro systemlog); SystemLog SelectSystemLog (String ID); int updateSystemlog (Systemlog Record);}Escreva classe de implementação de serviço serviceImpl
pacote com.gcx.service.impl; importar javax.annotation.resource; importar org.springframework.stereotype.service; importar com.gcx.annotation.log; import com.gcx.dao.systemLogMapper; importação com.gcx.entity.systemog; com.gcx.service.systemlogService; @Service ("SystemLogService") classe pública SystemLogServiceImpl implementa SystemLogService {@Resource Private SystemLogMapper SystemLogMapper; @Override public int DeLeTesystemLog (string id) {return SystemLogMapper.DeleteByPrimaryKey (ID); } @Override public int Insert (SystemLog Record) {return SystemLogMapper.insertSelective (registro); } @Override public SystemLog SelectSystemLog (String ID) {return SystemLogMapper.SelectByPrimaryKey (ID); } @Override public int updateSystemLog (SystemLog Record) {return SystemLogMapper.UpDateByPrimaryKeySelective (registro); } @Override public int InsertTest (SystemLog Record) {return SystemLogMapper.insert (Record); }}Aqui o programa básico está terminado
Abaixo está a anotação personalizada
pacote com.gcx.annotation; importar java.lang.annotation.*; @Target ({elementType.parameter, elementType.method}) @retention (retentionPolicy.Runtime) @Documented Public @Interface Log { / ** O tipo de operação a ser executado, como: como: operação* / ** A operação específica a ser executada, como: Adicionar usuário **/ public String OperaçãoName () padrão "";}Escreva o corte abaixo
pacote com.gcx.annotation; importar java.lang.reflect.method; importar java.util.date; importar java.util.uuid; importar javax.annotation.resource; import javax.servlet.htttp.htppsleTreQuest; importação; org.aspectj.lang.joinpoint; importar org.aspectj.lang.proedingJoinpoint; importar org.aspectj.lang.annotation.after; importar org.aspectj.lang.annotation.AfterReturning; importação; org.aspectj.lang.annotation.aspect; importar org.aspectj.lang.annotation.be antes; importar org.aspectj.lang.annotation.pointcut; import org.slf4j.logger; com.gcx.entity.user; importar com.gcx.service.systemlogservice; importar com.gcx.util.jsonutil;/*** @author yang jian* @e-mail: e-mail* @version chead: 2015-10-19 4:29:05 pm* @Desc-cuts* Class*/2015-10-19 4:29:05 pm* @Desc-cuts* Salvar logs no banco de dados @resource // Uso a anotação de recursos aqui, geralmente usando @Autowired. Suas diferenças. Se eu tiver tempo, escreverei o SystemLogService SystemLogService privado no blog subsequente; Logger final estático privado) = LoggerFactory.getLogger (classe SystemLogaspect. Class); // Camada do controlador Tangent Point @PointCut ("Execução (* com.gcx.controller ..*.* (..))") public void controleraspect () {}/*** pré-notificação é usado para interceptar a camada do controlador para gravar as operações do usuário** @param junção de ponto tangente*/ficar mais System.out.println("====================================================================================================== =============================================================== =============================================================== =============================================================== =============================================================== =============================================================== ================================================================ System.out.println ("============================================================================================== [TRYMILT) (ProceedingJoinPoint) Junção) .Proced (); System.out.println ("==============================================================================oMerMillis (); Logger.info ("em torno" + junção + " /TEUS TIME:" + (final - Iniciar) + "MS com exceção:" + e.getMessage ()); HttpServletRequest Request = (ServletRequestattributes) requestContextholder.getRequestAttributes ()). GetRequest (); = User (); Class.Forname (TargetsName); Method.getAnnotation (log.class) .OperationType (); System.out.println ("Método de solicitação:" + (junção de ponto de vista (). GetClass (). System.out.println ("Solicite IP:" IP); log.setMethod (junção.gettarget (). getClass (). getName () + "." LOG.SETEXCENTE (NULL); (Exceção e) {// Registre a exceção local logger.error ("== Exceção de pós-notificação =="); System.out.println ("====== Executar controlador pós-retorno Notificação ========); if (Logger.isInfoEnabled ()) {Logger.info (" AfterReturn " + JONPoint);}} / ** * A notificação de exceção é usada para intercepto da exceção" * * * * * * * * * * * "ControllerAspect ()", Throwing = "E") public void DoafterWring (Junção de junção, jogável e) { /*httpServletRequest Request = (servletRequestattributes) requestContextholder.getRequestTributes (). sessão.getattribute (WebConstants.Current_USER); (JONCOPOIGHT.GETARGS ()! = NULL && JOUNPOINT.GETARGS (). Length> 0) {for (int i = 0; i <junção.getargs (). length; i ++) {params += jsonutil.getjSonstr (junção.getargs () [i]) +"; junção.getTarget (). {if (Method.getName (). Equals (MethodName)) {class [] clazzs = Method.getParameterTypes (); /*============== OUTRATO DE CONSOLE ========* / System.out.println ("=============== Notificação de exceção Start ================================================================================================================================== ============================================================================================= ============================================================================================= ============================================================================================= System.out.println ("Informações de exceção:" + e.getMessage ()); System.out.println ("Requester:" User.getName ()); Log.SetId (UUID.Randomuuid (). ToString ()); LOGRATEMENTO DE LOGRAÇÃO (DESPLICAÇÃO DO FORMO DESCOMENTE ENTREGÁVEO DO MUITO SOBREOUNETIVO DESLOVEMENTE SOBREO NOUSTEMENTE DESCOMENTE ENTREGOLTE ENTREGOLTE ENTREGOLTE ENTREGOLTE Formulário de T. SystemlogService.insert (log); ex.getMessage ()); e.getclass (). getName (), e.getclass (). getName (), params);Escrevi muito aqui, incluindo notificação pré-notícia, notificação surround, pós-notificação, notificação de exceção e notificação pós-refeição. Tudo bem se eu não escrever tudo em nossa escrita real. Estou acostumado a escrever a lógica do log no pós-log. Vejo que algumas das notificações pré-log também estão incluídas nas notificações pré-log na Internet, mas sinto que é melhor escrevê-lo nas notificações pós-log.
Vamos começar a adicionar anotações personalizadas ao controlador! !
pacote com.gcx.controller; importar org.springframework.beans.factory.annotation.aUtowired; importar org.springframework.stereotype.controller; importação org.springframework.web.bind.annotation.requestMapping; importação com.gcx.gcx.notation.bind.annotation.requestMapping; importar com.gcx.gcx.notation.bind.annotation.requestMapping; importação com.gcx.service.userService;@controlador@requestmapping ("userController") classe pública UserController {@AUTowired private UserService UserService; @RequestMapping ("testaop") @Log (OperationType = "Adicionar operação:", OperaçãoName = "Adicionar usuário") public void testaop (string userName, string senha) {userservice.adduser (nome de usuário, senha); }}Escreva a classe de teste abaixo
@Test public void testaop1 () {// Iniciar o contêiner de mola ApplicationContext ctx = new ClassPathXMLApplicationContext (new String [] {"ClassPath: ApplicationContext-Mvc.xml", "ClassPath: ApplicationContext-Datasource.xml"}); // obtenha componente de serviço ou controlador UserController userController = (UserController) ctx.getBean ("userController"); UserController.testap ("Zhangsan", "123456"); }Dados do banco de dados:
Originalmente, eu queria escrever dois pontos tangentes, um é a camada de serviço e o outro é a camada do controlador. A camada de serviço é usada para registrar informações de exceção, enquanto a camada do controlador é usada para gravar funções. O resultado em execução é o seguinte.
Se você fizer isso, não sei se a eficiência da operação é boa no projeto real. Por favor, veja o Daniu do blog aqui para dar algumas sugestões! !
O exemplo acima da explicação do método de anotação personalizado da Spring AOP para implementar o gerenciamento de logs é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.