Antes de ler este artigo, você pode consultar o artigo " Compreensão simples dos exemplos de COOP e AOP e código da primavera " para entender brevemente o conteúdo relevante do COI e da AOP. Vamos ao tópico.
Este artigo criará o exemplo mais simples passo a passo para usar os recursos da Spring AOP, que é considerado uma demonstração iniciante da Spring AOP. Como iniciante, executar uma demonstração tão simples também foi atingida por muitas armadilhas.
Problema da OOP, suplementar à AOP
Quando precisamos introduzir o comportamento público em objetos dispersos, o OOP parece impotente. Ou seja, o OOP permite definir relacionamentos de cima para baixo, mas não é adequado para definir relacionamentos da esquerda para a direita. Por exemplo, a função de log. O código de log geralmente é disperso horizontalmente em todos os níveis de objeto, sem qualquer relação com a funcionalidade principal do objeto ao qual ele está disperso. O mesmo vale para outros tipos de código, como segurança, manipulação de exceções e transparência. Esse tipo de código irrelevante espalhado em todos os lugares é chamado de código cruzado. No design do OOP, causa muita duplicação de código, que não é propícia à reutilização de cada módulo.
O chamado "aspecto", simplesmente colocado, encapsula a lógica ou as responsabilidades que não estão relacionadas aos negócios, mas são chamadas em conjunto pelo módulo de negócios, que facilita a redução da duplicação de código do sistema, reduzindo o acoplamento entre os módulos e promovendo futuras operabilidade e manutenção.
Apoio à AOP na primavera
O agente AOP na primavera é responsável pela geração e gerenciamento dos contêineres do IOC da Spring, e suas dependências também são gerenciadas pelos contêineres do COI. Portanto, o proxy da AOP pode atingir diretamente outras instâncias de feijão no contêiner, e esse relacionamento pode ser fornecido pela injeção de dependência do contêiner do COI. A Spring usa o proxy dinâmico Java para criar proxy AOP por padrão, para que possa criar proxy para qualquer instância da interface. Quando a classe que precisa de um proxy não é uma interface proxy, o Spring muda automaticamente para o uso de proxy do CGLIB e também pode forçar o CGLIB.
A lógica deste exemplo é a seguinte: Existe uma classe de carro (classe executiva). Antes e depois do método Go na classe de carros, haverá registros de log correspondentes, mas a classe de carro em si não conhece nenhuma lógica do log.
Crie um projeto Maven e adicione dependências
Primeiro, crie um novo projeto Maven, use o modelo MaveNarchetyCickickStart, depois abra o arquivo pom.xml e adicione os pacotes de dependência necessários para a execução da Spring AOP.
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.0.5.RELEASE</version></dependency><dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>4.0.5.RELEASE</version></dependency><dependency> <PuerpId> org.springframework </frupiD> <stifactId> Spring-Context </ArtifactId> <Versão> 4.0.5.release </sisters> </dependency> <pendency> <purg-aDID> </ArtifactId.springFramework </roupidId> <ArtifactId> Spring-CoNText </artefactId> <PuerpId> org.springframework </frugiD> <stifactId> Spring-AOP </ArtifactId> <versão> 4.0.5.release </sipers> </dependency> <pendesency> <rugnid> org.aspectj </frupid> <stifactId> Ascestjweaver </sefameFactid> <versão> 1.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8.8 versão </groupid>
Escrevendo código de negócios
Adicionado um carro de classe executiva, incluindo um método go ()
pacote com.wowo.spring_aop_demo1; public class Car {public void Go () {System.out.println ("Go Go!"); }}Escreva facetas
A classe de log gravará a operação do sistema, mas a lógica de log não será escrita em todos os lugares da classe executiva, mas existe como uma classe de faceta.
pacote com.wowo.spring_aop_demo1; public class CarLogger {public void beforerun () {System.out.println ("Carra vai executar"); } public void depoisrun () {System.out.println ("Carra está em execução"); }}Esta classe de aspecto contém dois métodos, a saber, a pré-notificação e a pós-notificação.
Configurar associações através de feijão
Adicionado um novo arquivo de configuração, chamado bean.xml neste exemplo, para associar o rosto e as notificações no arquivo de configuração
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/Context" xmlns: aop = "htttp://schema" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd" > <bean id = "car" /> <bean id = "logger" /> <AOP: config> <aop: aspecto ref = "logger"> <aop: pointcut expressão = "Execution (* com.wowo.spring_aop_demo1.car.go (..)" id = "go" /> <arop: antes de ponto Pointcut-ref = "Go" Method = "Afterrun"/> </AOP: ASPECT> </AOP: Config> </ Beans>
NOTA: Neste arquivo de configuração, são necessários o espaço de nome da AOP e vários endereços contidos no XSI: Schemalocation.
Execution (* com.wowo.spring_aop_demo1.car.go (..)) é uma expressão de corte de pontos de aspecto. A execução significa desencadear durante a execução. O seguinte * representa o valor de retorno de qualquer tipo. com.wowo.spring_aop_demo1.car refere-se à classe onde o ponto pontual está localizado. GO (..) é o nome do método e ... representa qualquer parâmetro.
Existem 5 tipos de notificações que podem ser aplicadas às seções de mola:
・Antes-a notificação é chamada antes que o método seja chamado
・Após-uma notificação é chamada após a conclusão do método, independentemente de o método ser executado com sucesso.
・Após a retorno-a notificação é chamada depois que o método é executado com sucesso
・Após o lançamento-a notificação após o método lança uma exceção
・Em torno-Notificação Packers O método notificado e executa comportamento personalizado antes e depois da chamada do método notificado.
Execute o código comercial
Abaixo está uma classe que contém o método principal () para executar o código de negócios
pacote com.wowo.spring_aop_demo1; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classpathpathmlapplicationContext; public class {public static void main (string [] args) {ApplicationConten ClassPathXMLApplicationContext ("bean.xml"); Carro de carro = (carro) context.getBean ("carro"); carga(); }}No código acima, um objeto de carro é criado pela primavera. Quando a primavera cria esse objeto, descobre que um de seus métodos é configurado como Pointcut. Portanto, ao instanciar o objeto, um objeto proxy será criado. Quando o método pontual Go () é executado, ele será interceptado pelo objeto proxy criado pelo Spring. Antes de executar o método GO, ele chamará o correspondente pré-processamento de pré-processo correspondente, ligue para o método car.go () e, em seguida, chamará o pós-processo da classe de seção Carlogger Afterrun ().
Nota: A mola deve ser usada para criar um objeto que contém tangentes. Se você criar você mesmo, a primavera não poderá monitorá -lo e sua operação não será notificada aplicando nenhum aplicativo.
O resultado da saída do projeto é
O carro vai para Rungo Go Go! O carro está correndo
Use notificações surround
Se você deseja usar notificações surround, precisamos modificar os métodos de notificação e arquivos de configuração na classe Aspect. A classe executiva não precisa fazer nenhuma modificação porque é completamente dissociada. Primeiro modifique a seção da classe Carlogger
importar org.aspectj.lang.proecedingJoinPoint; public class CarLogger {public void em torno da RUN (ProceedingJoinPoint Junção) {System.out.println ("O carro vai executar"); tente {// chamando o método de destino do objeto proxy, neste exemplo apontando para o car.go () método junçãoPoint.proeced (); } catch (throwable e) {e.printStackTrace (); } System.out.println ("Carra está em execução"); }}O método em torno da notificação precisa aceitar parâmetros de tipo de prosseguir o ponto de união e seu método Process () chamará o método de destino do objeto proxy; portanto, em circunstâncias normais, esse método deve ser chamado. Também podemos organizar a execução do objeto proxy, não chamando esse método.
Em seguida, modifique a parte da AOP: Config do arquivo de configuração para o seguinte
<AoP: config> <aop: aspecto ref = "Logger"> <AOP: Pointcut Expression = "Execution (* com.wowo.spring_aop_demo1.car.go (..))" id = "go"/> <aOp: em torno do método = "toundrun" point-ref = "go"/>
Nota: As notificações surround não podem existir ao mesmo tempo que as notificações frontal/traseiro. Depois de executar o código, o resultado da saída permanece inalterado.
Resumir
O exposto acima é todo o conteúdo compartilhado por este artigo sobre a introdução à demonstração da Spring AOP, espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!