Este artigo apresenta o método de usar aOP no projeto Springboot. Vou compartilhar com você. Os detalhes são os seguintes:
1. Visão geral
O uso da lógica geral para implementar a tecnologia AOP pode simplificar bastante a redação de programas, como verificação de assinatura, autenticação, etc. As transações declarativas da Spring também são implementadas através da tecnologia AOP.
Para um código específico, consulte o exemplo do projeto https://github.com/qihaiyan/springcamp/tree/master/spring-aop
A tecnologia AOP da primavera tem quatro conceitos principais:
Pointcut: corte de pontos, usado para definir qual método será interceptado, por exemplo, execução (*CN.Springcamp.springaop.service.*.*(..))
Conselho: A ação a ser executada após interceptar o método
Aspecto: Fatia, combine pointcut e conselhos para formar uma superfície cortada
Ponto de junção: uma instância do Pointcut durante a execução
Weaver: Uma estrutura para implementar aOP, como aspecto ou mola AOP
2. Definição Ponto de definição
As definições de pós -poço comumente usadas incluem execução e @annotation. A execução define uma isenção de métodos e é usada para implementar uma seção relativamente comum. @Annotation pode ser adicionado como anotação a métodos específicos, como a anotação da transação da Spring.
A definição de corte de ponto de execução deve ser colocada em uma classe pública para gerenciar centralmente a definição de corte de pontos.
Exemplo:
classe pública CommonJoinPointConfig {@PointCut ("Execution (*cn.springcamp.springaop.service.*.*(..)") public void servicelayerexecution () {}}Dessa maneira, na classe de aspecto específica, você pode se referir ao ponto tangente através do CommonJoinPointConfig.ServiceLayeRexecution ().
public class BeForeaspect {@Before ("CommonJoinPointConfig.ServiceLayeRexecution ()") public void antes (junção junção) {System.out.println ("-------------> antes do aspecto"); System.out.println ("---------------> Antes da execução de" + junção); }}Quando o ponto tangente precisa ser alterado, você só precisa modificar a classe CommonJoinPointConfig, sem modificar cada classe de aspecto.
3. Corte de rosto comumente usado
Antes: Execute o conselho antes que o método seja executado, que é frequentemente usado para verificação de assinatura, autenticação etc.
Depois: Executar após a conclusão da execução do método, se a execução é bem -sucedida ou a exceção é lançada.
Após o retorno: Execute somente após a execução do método ser bem -sucedida.
Após o arremesso: Execute somente após uma execução de método lançar uma exceção.
Um aspecto simples:
@Aspecto @componentpublic class beforeaspect {@before ("CommonJoinPointConfig.ServiceLayeRexecution ()") public void antes (junção junção) {System.out.println ("---------------> antes do aspecto"); System.out.println ("--------------> antes da execução de" + junção); }}4. Anotações personalizadas
Suponha que queremos coletar o tempo de execução de um método específico, uma maneira mais razoável é personalizar uma anotação e, em seguida, adicionar essa anotação ao método que precisa coletar o tempo de execução.
Primeiro defina um tempo de trilha de anotação:
@Target ({elementType.method, elementType.type}) @retention (retentionpolicy.runtime) public @Interface TrackTime {String param () padrão "";}Em seguida, defina uma classe de aspecto para implementar o comportamento da anotação:
@Aspecto@componentPublic class TracktimeAspect {@Alound ("@anotação (tracktime)") Public Object em torno (ProceedingJoinPoint JUNCPOINT, tracktime TimeTime) lança Throwable {objeto resultado = null; long startTime = System.currenttimemillis (); resultado = junçãoPoint.proeced (); long timeTaken = System.currenttimemillis () - StartTime; System.out.println ("------------> tempo gasto por" + junção + "com param [" + rastrear.param () + "] é" + timetaken); resultado de retorno; }}Ao usar esta anotação em um método, você pode coletar o tempo de execução deste método:
@TrackTime (param = "myService") public string runfoo () {System.out.println ("----------------> foo"); retornar "foo";}Observe que a anotação @TrackTime (param = "MyService") pode ser passada.
Para que as anotações passem parâmetros, você precisa especificar um parâmetro string param () padrão "padrão" ao definir anotações.
Ao mesmo tempo, na classe de aspecto, os parâmetros correspondentes são adicionados ao método ao redor. O nome da variável do parâmetro também é necessário para ser o tempo de faixa na anotação @around, mas não no nome da classe.
@Alound ("@anotação (tracktime)") Objeto público em torno (ProceedingJoinPoint JoinPoint, TrackTime TimeTime)5. Resumo
Ao executar o projeto de amostra, o console gera o seguinte:
----------------> antes do aspecto
---------
---------------> Foo
-----------
---------------> After Aspect
---------
-----------------> aspecto após retornar
----------------
Pode -se observar que a ordem de execução de vários aspectos é antes depois de reverter após o retorno (após o arco)
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.