AOP eu acho que todo mundo é muito claro. Às vezes, precisamos processar alguns registros de solicitação ou monitorar alguns métodos e o que deve ser tratado se houver exceções? Agora, apresentamos a AOP da Spring-Boot.
[Ambiente de desenvolvimento: o número da versão JDK é 1.8, primavera
O número da versão da bota é 1.4.1] {style = ”Background-Color:#FF0000”}
Primeiro, apresentaremos o pacote JAR primeiro.
O arquivo POM é adicionado da seguinte forma:
<!-cite aop-> <pendency> <puperiD> org.springframework.boot </frugiD> <stifactId> spring-boot-starter-aOP </sutifactId> </dependency> <!-cite gson, para a impressão-> <Pusency> <puriD> com.google.code.gson </groupid, <Versão> 2.7 </sisters> </dependency>
Depois de introduzir o pacote JAR, adicionamos dois métodos simples de processamento de solicitação para inicializar a inicialização:
@SpringbooTApplication (scanBasePackages = {"com"})@RestControllerPublic Classe DemoApplication {public static void main (string [] args) {springapplication.run (DemoApplication.class, args); } // Teste uma solicitação GET sem argumentos @RequestMapping (value = "/testaspect", método = requestmethod.get) public uservo test () {uservo uservo = new uservo (); uservo.setage ("23"); uservo.setName ("He Xiaowu"); uservo.setsex ("masculino"); retornar USERVO; } // Teste a solicitação GET com parâmetros, deixe a AOP imprimir o parâmetro Content @RequestMapping (value = "/testaspectargs", Method = requestMethod.get) Teste Public UserVo (Nome da String, Age da String, String Sex) {UserVo UserVo = new Uservo (); uservo.setName (nome); uservo.setage (idade); uservo.setsex (sexo); retornar USERVO; }Depois de adicionar dois métodos simples de processamento de solicitação, vamos adicionar nossa AOP
/** * Nome do projeto: SpringbootDemo * Criador: He Xiaowu * Tempo de criação: 16/12/4 19:05 * Nome da classe: AspectoDemo * Classe Descrição: * /// Declare é uma seção@aspecto //) private gson gson = new gson (); // Declare um ponto na expressão de execução @pointcut ("Execução (public * com.example.demoApplication. * (..))") private void controleraspect () {} // imprima o conteúdo antes de solicitar o método @before (value = "controleraspect ()") public void Methodbefore (junção junção) { (ServletRequestattributes) requestContextholder.getRequestAttributes (); HttpServletRequest request = requestAttributes.getRequest (); // Imprima o conteúdo da solicitação log.info ("======================================================= ================================================================= ================================================================= ================================================================== ================================================================= ================================================================== ================================================================= ================================================================== // Imprima o conteúdo de retorno após o método ser executado @afterReturning (returning = "o", Pointcut = "controleraspect ()") public void MethodafterReturning (Object O) { log.info ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Depois que os dois estão configurados, solicitamos e, em seguida, visualizamos o log de impressão. Primeiro, inicie nosso contêiner e depois solicitamos o método de processamento parametrizado. O registro de impressão é o seguinte:
{width = ”1232”
altura = ”132”}
Pode -se descobrir que o URL solicitado, o método, os valores dos parâmetros do ARGS, os tipos e o conteúdo retornado são impressos, indicando que esta é a interceptação da AOP com sucesso.
Em seguida, testamos o método de processamento de solicitação sem parâmetros e imprimimos o log da seguinte forma:
{width = ”1100”
altura = ”130”}
Podemos descobrir que os parâmetros do método impressos neste método são uma matriz vazia porque o método não requer passagem de parâmetro.
O acima é que o Springboot faz referência à AOP para processamento de log do processamento da Web. Aqui estão algumas anotações principais para as seções AOP. A seguir, são apenas descrições e uso das anotações. O autor não os testará em detalhes. Se você estiver interessado, você pode testá -los você mesmo:
Anotação de classe:
@Aspect Define uma classe como uma classe de aspecto
@Order (i) marca a prioridade do processamento da classe FACET. Quanto menor o valor i, maior o nível de prioridade. PS: Você pode anotar a classe ou anotar o método.
Anotação do método:
@Pointcut define um método como um ponto de corte como uma expressão, os seguintes detalhes
@Efore Executa o método antes do ponto tangente, o conteúdo é o ponto tangente especificado
@After executa após corte de pontos, antes de retornar,
@AfterReturning é executado após o ponto de entrada e retornar. Se você deseja processar os parâmetros de retorno de alguns métodos, poderá operá -lo aqui.
@Around cercando o ponto tangente, execute antes de entrar no ponto tangente e depois do ponto tangente
@Afterwlowing joga uma exceção após o ponto de fenda para o processamento
@Order (i) marca a prioridade do corte de pontos. Quanto menor o i, maior a prioridade
@PointCut Anotation Combination:
No código acima, definimos um ponto tangente que apenas processa o caminho especificado:
@PointCut ("Execution (public * com.example.DemoApplication.Agora, estamos definindo um ponto tangente para lidar com outros caminhos:
@PointCut ("Execução (public*com.demo.*.*(..))") private void controlerDemo () {}Os pontos tangentes acima são todos processados separadamente. Se precisarmos de um ponto tangente para processar os dois, podemos configurá -lo assim:
@PointCut (Value = "ControllerAspect () || controlerDemo ()") private void all () {} Na anotação @PointCut, consulte diretamente outros nomes de métodos anotados por @pointcut, para que o corte de pontos possa lidar com os métodos sob dois caminhos
@PointCut Anotation Execution Expression: public*com.demo.*.*(..)
O primeiro modificador público representando o método pode usar * em vez do primeiro * para representar o valor de retorno e * representa todos
com.demo.* Caminho do pacote,.* Representa o terceiro pacote no caminho.* Representa os métodos de todas as classes em todos os pacotes sob o caminho.
(..) significa parâmetros de método ilimitado
Algumas notas sobre @order (i) anotação:
A classe de anotação, quanto menor o valor, maior a prioridade, o método de anotação, as duas anotações são anotadas: @EBE, quanto menor o valor I, maior a prioridade, maior a prioridade, mais anotada: @after ou @afterreturning, maior o valor I, maior a prioridade.
Para resumir os dois, é:
Na operação antes do ponto de entrada, a operação após o ponto de entrada é realizado pelo valor da ordem de pequeno a grande, e a operação após o ponto de entrada ser realizado pelo valor da ordem de grande a pequeno
estender:
Alguns leitores podem perguntar, se eu quero imprimir o tempo necessário para a solicitação da variável de entrada e final, definir uma variável de membro para contar o tempo e dar @Before e @AfterReturning Acesso, pode haver problemas de sincronização. Portanto, nos referimos a um objeto Threadlocal que especifica o tipo genérico. O tempo de registrar a solicitação em @Before e deduzir o registro em @afterrenutring é o tempo consumido. O código é o seguinte:
/** * Nome do projeto: SpringbootDemo * Criador: He Xiaowu * Tempo de criação: 16/12/4 19:05 * Nome da classe: AspectDemo * Classe Descrição: * /// Declaração é uma seção@aspecto // declaração é um bEan gerenciado na primavera@component@component (1) a classe pública (ASPETDEMO {Private Logger Logger private gson gson = new gson (); Threadlocal <long> startTime = new Threadlocal <long> (); // Declare um ponto na expressão de execução @pointcut ("Execução (public * com.example.demoApplication. * (..))") private void controleraspect () {} // imprima o conteúdo antes de solicitar o método @before (value = "controleraspect ()") public MethodBefore (junção junção). ServletRequestattributes requestAttributes = (servletRequestattributes) requestContextholder.getRequestAttributes (); HttpServletRequest request = requestAttributes.getRequest (); // Imprima o conteúdo da solicitação log.info("=========================================================================================================== ============================================================= ============================================================== ============================================================= ============================================================== ============================================================== ============================================================== Arrays.ToString (junção.GeTargs ())); log.info("========================================================================================================== Arrays.ToString (junção.GeTargs ())); log.info ("Conteúdo da resposta:" + gson.tojson (O)); Log.info ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Os acima são todos os resultados obtidos pelo meu teste. Pode haver diferenças ou erros. Por favor, me corrija.
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.