Métodos de impressão de logs da interface usando AOP no Springboot

Prefácio

AOP é a abreviação da programação orientada para aspectos. É um conceito que é oposto à programação orientada a objetos. Na programação orientada a objetos, tendemos a adotar conceitos como encapsulamento, herança e polimorfismo para implementar cada função no objeto. No entanto, em situações reais, também descobrimos que há outro requisito de que seja necessário um tipo de função em muitos métodos de muitos objetos. Por exemplo, alguns métodos para acesso ao banco de dados têm requisitos de gerenciamento de transações e muitos métodos requerem logs de impressão. De maneira orientada a objetos, essas mesmas funções devem ser implementadas em muitos lugares ou chamadas em muitos lugares. Isso é muito pesado e está intimamente associado a esses requisitos independentes de negócios. Então, mais tarde, a programação orientada a aspectos parecia resolver esse tipo de problema e fez bons suplementos para a programação orientada a objetos

conceito

Para entender bem a programação orientada a tangente, você deve primeiro entender alguns conceitos de AOP. Em Java, o AspectJ implementa as funções da AOP de uma maneira relativamente completa, mas também é mais complexo de usar, então aqui é principalmente discutir a AOP da Spring. A Spring AOP adota o princípio da simplicidade e adequação para realizar as funções principais da AOP. Vamos falar sobre os conceitos específicos na AOP primeiro

1. Aspecto: aspecto. Um foco que pode ser inserido em várias classes. Esse foco realiza as funções comerciais específicas que mencionamos anteriormente. Por exemplo, impressão de toras, executando o gerenciamento de transações de banco de dados, etc.
2. Ponto da articulação: sendo cortado em ponto. Refere -se ao ponto em que o gerenciamento de transações do banco de dados é inserido especificamente para implementar o mencionado acima, como impressão de logs e gerenciamento de transações de banco de dados. Ou seja, o local do programa em que a função FACE é adicionada dinamicamente ao programa através da AOP. Na primavera AOP, isso se refere a um determinado método
3. Pointcut: ponto de corte. Usado para indicar como combinar pontos conjuntos por regras. Esta regra é uma expressão. Na primavera, o padrão é a linguagem de expressão de ponto de aspecto de aspecto
4. Conselho: indica a ação tomada em diferentes locais em um ponto de entrada. Por exemplo, para um gerenciamento de transações de acesso ao banco de dados, a transação deve ser iniciada após a entrada do método, a transação deve ser enviada antes do término do método e a transação deve ser revertida quando ocorrer um erro. Isso pertence a três conselhos diferentes e precisa ser implementado separadamente. O conselho é geralmente associado a cortes específicos.
5. Proxy da AOP: proxy AOP. Usado para implementar um método para adicionar dinamicamente funções de aconselhamento ao Pointcut. Na AOP da primavera, o proxy dinâmico e o proxy do CGLIB são implementados. AspectJ usa um método de invasão no bytecode por um compilador específico.

Implementação da Sprinboot AOP

Utilizamos vários capítulos para descrever o uso básico do Springboot. Então, aqui usamos Springboot e AOP para combinar para implementar uma função de saída de todos os parâmetros de entrada de interface REST e logs de parâmetros de retorno.

Implementar a função de serviço restante.

De acordo com o artigo anterior, primeiro construiremos um projeto de trampolim, como mostrado na figura a seguir

Projeto de demonstração

Configuração do projeto Springboot

Configuramos projetos de trampolim da seguinte maneira

 Servidor: Porta: 3030 Servlet: contexto: /aOP-DemoSpring: Jackson: Date-Format: AAAA-MM-DD HH: MM: SS Serialization: Indent-Output: TrueLogging: Nível: com.yanggch: depuração

A configuração relacionada a Jackson é emitir objetos em strings JSON e formatar a saída.

Classe de controlador que implementa uma interface de repouso

Aqui implementamos duas interfaces de descanso. Uma é devolver a informação do Hello. Uma é retornar as informações de login com base na entrada.

 pacote com.yanggch.demo.aop.web; import com.yanggch.demo.aop.domain.loGinentity; importação com.yanggch.demo.aop.domain.SecurityEntity; importação org.springframework.web.bind.annationAThathPathPaLeable; org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.RestController;import java.util.date;/*** Serviço de repouso relacionado à segurança** @Author: yang gaochao* @since: 2018-05-27*/ @RestController @requestmapping ("/api/v1/segurança") public class SecurityApi {@RequestMapping (value = "/Login/{{{{{{{ Login (@RequestBody Loginentity Loginentity, @PathVariable Long ShopId) {SecurityEntity SecurityEntity = new SecurityEntity (); Segurança.Setshopid (ShopId); SecurityEntity.SetAccount (Loginityity.getAccount ()); SecurityEntity.Setpwd (Loginentity.getpwd ()); SecurityEntity.SetLogIntime (new Date ()); retornar a segurança; } @ReQuestMapping (value = "/echo/{name}", método = requestmethod.get) public string login (@pathvariable string nome) {return "hello" + name; }}

Primeiro, queremos produzir os parâmetros de entrada e retornar os resultados de todas as interfaces de REST para o log através da função AOP.

Implementar funções da Web AOP.

 pacote com.yanggch.demo.aop.comment; importar com.fasterxml.jackson.databind.objectmapper; importar org.aspectj.lang.joinpoint; importar org.aspectj.lang.annoTation.aspect; importar org.aspectj.lang.annatation.before; org.slf4j.logger; importar org.slf4j.loggerFactory; importar org.springframework.beans.factory.annotation.autowired; import org.springframework.teroType.component; importar org.springframework.web.multiptypey.multiptile; javax.servlet.http.httpServletRequest; importar javax.servlet.http.httpServletResponse;/*** Log da interface da web** @author: yang gaochao* @since: 2018-05-27*/ @aspecto @componentpublic Class LoggerFactory.getLogger (webLogaspect.class); Mapper de ObjectMapper final privado; @Autowired Public WebLogasPepe (ObjectMapper Mapper) {this.mapper = mapper; } @PointCut (" @AnoTation (org.springframework.web.bind.annotation.requestMapping)") public void weblog () {} @before ("webLog ()") public void comofore (jun JoinPoint) {para (objeto de objeto: junção () ") (). HttpServletRequest ||. } tente {if (log.isdebugenabled ()) {log.debug (junção.gettarget (). getClass (). getName () + "." + junçãoPoint.getSignature (). }} catch (Exceção e) {e.printStackTrace (); }}} @AfterReturning (returning = "Response", Pointcut = "webLog ()") public void DoafterReturning (resposta do objeto) lança lançável {if (resposta! = Null) {log.debug ("Parâmetro de resposta:" + mapper.writeValueasstring (resposta)); }}}

Aqui estão algumas coisas para prestar atenção.

1. O org.aspectj.lang.annotation.aspect Anotation precisa ser declarado na classe.
2. Um Pointcut precisa ser declarado através da anotação org.aspectj.lang.annotation.pointcut no método para indicar quais métodos entrar. Nossa interface de repouso possui a anotação org.springframework.web.bind.annotation.requestmapping, por isso usamos a expressão "@annotation (org.springframework.web.bind.annotation.requestmapping)" para indicá -la.
3. Use conselhos para explicar o que fazer no ponto de inserir o método. Aqui está org.aspectj.lang.annotation.be antes
4. Esta implementação indica que, em todos os métodos com org.springframework.web.bind.annotation.requestmapping anotação, os parâmetros de entrada são impressos após a entrada do método. Após o retorno do método, o parâmetro de retorno é impresso.

teste

Em primeiro plano, a solicitação é iniciada através do Postman, e o resultado da entrada do log de plano de fundo é o seguinte

2018-05-27 19: 58: 42.941 Debug 86072 --- [nio-3030-exex-4] c.yanggch.demo.aop.comment.weblogaspect: com.yanggch.demo.aop.web.securityapi.login: request Parameter: {{{{{{{{
"Conta": "Yanggch",
"PWD": "123456"
}
2018-05-27 19: 58: 42.941 Debug 86072 --- [nio-3030-exex-4] c.yanggch.demo.aop.comment.weblogaspect: com.yanggch.demo.aop.web.s
2018-05-27 19: 58: 42.942 Debug 86072 --- [nio-3030-exex-4] c.yanggch.demo.aop.comment.weblogaspect: Parâmetro de resposta: {{
"Shopid": 2001,
"Conta": "Yanggch",
"PWD": "123456",
"LogIntime": "2018-05-27 11:58:42"
}
2018-05-27 19: 58: 45.796 Debug 86072 --- [nio-3030-exex-5] c.yanggch.demo.aop.comment.weblogaspect: com.yanggch.demo.aop.web.s
2018-05-27 19: 58: 45.796 Debug 86072 --- [nio-3030-exex-5] c.yanggch.demo.aop.comment.weblogaspect: Parâmetro de resposta: "Hello, yanggch"

A partir disso, podemos ver que, embora não escrevamos o código para produzir o log no método da interface restante, podemos adicionar automaticamente o código para produzir os parâmetros de entrada e retornar parâmetros a cada método de entrada de repouso através da AOP e executá -lo corretamente.

Outras instruções

Os tipos de conselhos e a linguagem de expressão de AOP para Pointcut são mencionados anteriormente. Para referências específicas, consulte a eles da seguinte maneira.

Tipo de conselho

1. Antes que o conselho seja executado antes da execução do método.
2. Depois de retornar o conselho executado após a execução do método, retorne um resultado.
3. Depois de lançar conselhos, é executado quando uma exceção é lançada durante a execução do método.
4. O conselho é executado antes e depois que o método é executado e quando uma exceção é lançada, o que equivale a combinar as três notificações acima.

Linguagem de expressão de AOP

1. MOTEMETRA MACHAMETR
@args ()

2. Método Descrição Comparação
execução (modificadores-padrão?
onde o padrão de retorno, o padrão de nome e o padrão de parâmetros é necessário.
. Padrão do tipo ret: pode ser um nome de classe que representa qualquer valor de retorno, caminho completo, etc.
*. Nome-padrão: especifique o nome do método, * representa todos
.set representa todos os métodos que começam com o conjunto.
. Padrão de parâmetros: especificar parâmetros do método (tipo declarado), (..) representa todos os parâmetros e () representa um parâmetro
. (, String) significa que o primeiro parâmetro é qualquer valor e o segundo é da string do tipo.

3. Combinação atual do tipo de objeto de proxy AOP

4. Classe alvo correspondente
@alvo()
@dentro de()

5. Métodos de correspondência marcados com esta anotação
@anotação()

O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.