Índice
1. Spring AOP baseada na configuração XML
2. Use anotações para configurar AOP
3.
4. Notas de notificação de aspecto
5. Configuração zero para implementar o COI da primavera e AOP
AOP (Programação Orientada por Aspectos) é uma tecnologia que implementa o controle unificado multi-modula horizontal das funções do programa por meio de métodos de pré-compilação e agentes dinâmicos durante o tempo de execução. AOP é um suplemento ao OOP e uma parte importante da estrutura da mola. As várias partes da lógica de negócios podem ser isoladas usando a AOP, reduzindo assim o acoplamento entre as várias partes da lógica de negócios, melhorando a reutilização do programa e melhorando a eficiência do desenvolvimento. AOP pode ser dividida em tecelagem estática e tecelagem dinâmica. A tecelagem dinâmica não requer alteração do módulo de destino. A Spring Framework implementa a AOP e o uso da anotação para configurar a AOP é mais conveniente e intuitivo do que usar a configuração XML.
1. Spring AOP baseada na configuração XML
Antes de explicar a anotação para implementar a função AOP, primeiro use o aprendizado anterior para configurar a função da Spring AOP usando XML, para que seja para comparação e melhor compreensão.
1.1.
<Projeto xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-inStance" xsi: schimalocation = "htttp.mlst.mtance. org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modymOlVersion> <puperid> com.zhangguo </foupiD> <TRARFACTID> spring052 </artifactid> <Versão> 0.0.1-SNAPSHOT </SSELHE> <backaging> jar </chaveging> <name> spring052 </name> <url> http://maven.apache.org </url> <projeds> <projeto.build.sourceEncoding> utf-8 </projild.build.build.build.build.sources.sourcent. </Properties> <pendências> <pendency> <puerpiD> Junit </foupid> <TRATIFACTID> JUNIT </STIFACTID> <SCOPE> Test </copo> <Versão> 4.10 </versão> </dependency> <pendency> <voundid> org.springframework </foupid> <TRAFACTID> Spring-Context </stimafactId> <Version> $ {spring.version} </versão> </dependency> <pursic> <pursw. /Dependência> <Depencency> <puperId> cglib </groupid> <TarfactId> CGLIB </ArtifactId> <versão> 3.2.4 </version> </dependency> </dependências> </Project>1.2.
pacote com.zhangguo.spring052.aop01; System.Println (n1+"-"+n2+"="+resultado); resultado = n1*n2;
1.3.
pacote com.zhangguo.spring052.aop01; importar org.aspectj.lang.joinpoint;/*** --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1.4.
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 springframework.org/schema/p "xmlns: aop =" http://www.springframework.org/schema/aop "xsi: schemalocation =" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd"> <!-- proxy object --> <bean id="math"></bean> <!-- notification--> <bean id="advices"></bean> <!-- aop configuration--> <aop:config proxy-target-class="true"> <!-- section--> <aop:aspect ref="advices"> <!-- point--> <aop:pointcut Expression = "Execution (* com.zhangguo.spring052.aop01.math </ Beans>
1.5.
pacote com.zhangguo.spring052.aop01; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classpathPathClatplicsContext; classe public {public static void Maid (string [] args) {ApplicationConText; l "); matemática matemática = ctx.getBean (" matemática ", math.class); int n1 = 100, n2 = 5; Math.Add (N1, N2);Resultados em execução:
2. Use anotações para configurar AOP
2.1. É equivalente a adicionar um feijão ao arquivo de configuração XML no exemplo anterior, <!-objeto proxy-> <bean id = "math"> </shean>, e o código da classe de matemática é o seguinte:
pacote com.zhangguo.spring052.aop02; importar org.springframework.tereotype.service;/*** // substitua public int sub (int n1, int n2) {int resultado = n1-n2; System.Println (n1+"-"+n2+"=" Resultado); println (n1+"/"+n2+"=" Resultado);2.2.
pacote com.zhangguo.spring052.aop02; importar org.aspectj.lang.joinpoint; importar org.aspectj.lang.annotation.aspect; importar org. @Componente @Aspecpublic Class ADVICES {@Before ("Execution (* com.zhangguo.spring052.aop02.math. ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------O código acima é basicamente o mesmo que a seguinte configuração
<!-Notificações-> <bean id = "Avice"> </i bean> <!-AOP Configuration-> <AOP: config proxy-alget-class = "true"> <!-seção-> <aOP: Aspect = "Advices"> <! ut1 "/> <!-Connect Notification Method and Point-> <AOP: Antes do método =" Antes "Pointcut-ref =" Pointcut1 "/> <AOP: após Method =" After " Pointcut-ref = "Pointcut1"/> </AOP: Aspect> </AOP: config>
2.3.
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 springframework.org/schema/p "xmlns: aop =" http://www.springframework.org/schema/aop "xmlns: context =" http://www.springframework.org/schema/Contet " xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd"> <Contexto: component-Scan Base-Package = "com.zhangguo.spring052.aop02"> </context: component-scan> <AOP: AspectJ-Autoproxy proxy-Target-class = "True"> </AOP: Aspecj-AutoProxy> </s Beans>
2.4.
pacote com.zhangguo.spring052.aop02; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classPathPathClationClicationContext; classe public {public static void Maid (string [] args) {ApplicationConten (publicl) "); Matemática matemática = ctx.getBean (" math ", math.class); int n1 = 100, n2 = 5; Math.Add (N1, N2);Resultados em execução:
3.
A função tangente pode ser posicionada em uma posição lógica transversal precisa. direcionamento diferente.
@Aspectj usa a expressão especial de ponto de aspecto para descrever a seção.
Função de corte de ponto do método: define pontos de conexão descrevendo as informações do método da classe de destino.
Função de corte de ponto do parâmetro do método: define pontos de conexão descrevendo as informações do parâmetro do método da classe de destino.
Função de corte de ponto de alvo: define pontos de conexão descrevendo as informações do tipo de classe de destino.
Função de corte da classe do agente: define pontos de conexão descrevendo as informações da classe proxy.
Funções de expressão de aspecto comum:
A função de corte de pontos mais usada é: Execução (<Modo modificador>? <Modo de retorno Tipo> <Modo de nome do método> (<Modo de parâmetro>) <Modo de exceção>?) Função de corte de pontos, que pode atender à maioria das necessidades.
Para mostrar as funções de cada função tangente de ponto, uma nova classe Strutil agora é adicionada, a classe é a seguinte:
pacote com.zhangguo.spring052.aop03; importar org.springframework.tereotype.component; @component ("strutil") public class strutil {public void show () {System.out.println ("hello strutil!");O código de teste é o seguinte:
pacote com.zhangguo.spring052.aop03; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classpathPathClatplicsContext; classe public {public static vaid main (string [] args) {ApplicationConText; "); IMATH MATH = CTX.GETBEAN (" MATH ", MATH.CLASS); INT N1 = 100, N2 = 5; Math.Add (N1, N2);3.1.
pacote com.zhangguo.spring052.aop03; importar org.aspectj.lang.joinpoint; importar org.aspectj.lang.annotation.aspect; importar org. @Componente @Aspecpublic Class ADVICES {@Before ("Execution (* com.zhangguo.spring052.aop03.math O pacote OP03 é cortado em @after ("Execução (*com.zhangguo.spring052.aop03.*.*(..))") public void após (junção jp) { System.out.println ("---------------------------------");Os resultados da operação são os seguintes:
Execução (<Modo modificador>? <Modo de tipo de retorno> <Modo de nome do método> (<Modo de parâmetro>) <Modo de exceção>?)?)?
3.2.
// dentro da função de corte de pontos // com.zhangguo.spring052.aop03 Pacote Todos os métodos de todas as classes são cortados em @after ("dentro (com.zhangguo.spring052.aop03.3.3
//this point-cut function//Implements any connection point of the proxy object of the IMath interface @After("this(com.zhangguo.Spring052.aop03.IMath)") public void after(JoinPoint jp){ System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------3.4
/Args Função de corte de pontos // requer que o método tenha duas referências de tipo INT antes de serem tecidas na lógica cruzada @after ("args (int, int)") public void após (junção jp) {System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Se o tipo de parâmetro não for o tipo de dados de base, o nome do pacote será necessário.
3.5
Primeiro personalize uma anotação que pode ser anotada no método
pacote com.zhangguo.spring052.aop03; importar java.lang.annotation.documented; importar java.lang.annotation.ElementType; importar java.lang.annotation.rettem ention(retEntionPolicy.runtime)@documentedpublic @interface myanno {} //@@annotation point-cut funct // requer o método deve ser anotado com.zhangguo.spring052.aop03.myanno a ser tecido na lógica de corte transversa } pacote com.zhangguo.spring052.aop03; importar org.springframework.tereotype.component; @component ("strutil") classe pública strutil {@myanno public void show () {System.out.println ("hello strutil!");Resultados em execução:
Outras funções de corte de pontos com @ são para anotação
4. Notas de notificação de aspecto
As anotações de notificação de aspecto têm 6, 5 são comumente usadas e menos introduções são usadas.
Primeiro, resolva o problema de definir a multiplexação tangente de pontos, como mostrado no código a seguir, o conteúdo da função tangente de pontos é exatamente o mesmo:
pacote com.zhangguo.spring052.aop04; importar org.aspectj.lang.joinpoint; importar org.aspectj.lang.annotation.aspect; importar org. @Componente @Aspecpublic Class ADVICES {@Before ("Execution (* com.zhangguo.spring052.aop04.Math. ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Você pode primeiro definir uma tangente e depois multiplicar a seguinte:
pacote com.zhangguo.spring052.aop04; importar org.aspectj.lang.joinpoint; importar org.aspectj.lang.annotation.aspect; importar org.aspectj.lang.annoTation.Before; importação; @Componente@AssembarpPublic Class Avice { // 切点 @PointCut ("Execução (* com.zhangguo.spring052.aop04.math ()); System.out.println ("---------------------------------");Modifique o arquivo ADVICS.Java e adicione vários tipos de notificação da seguinte forma:
pacote com.zhangguo.spring052.aop04; importar org.aspectj.lang.joinpoint; importar org.aspectj.lang.proedingJoinPoint; importação org.aspectj.lang.annoTation.after; importar org.lapestj.lang.annotation.AnTurnting; anotação. org.aspectj.lang.annotation.pointcut; importar org.springframework.stereotype.component;/*** -Notice @Before ("Pointcut ()") public void antes (Junção JP) { System.Println (JP.GetSignature (). GetName ()); ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Throwable {System.out.println (pjp.getSignature (). GetName ()); ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Após o Returning (JunPoint JP, resultado do objeto) {System.out.println (jp.getSignature (). getName ()); ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ System.Println (JP.GetSignature (). GetName ());Resultados em execução:
5. Configuração zero para implementar o COI da primavera e AOP
Para obter uma configuração zero, com base no exemplo original, adicionamos uma nova classe semelhante ao usuário, como mostrado abaixo:
pacote com.zhangguo.spring052.aop05; public class Usuário {public void show () {System.out.println ("um objeto de usuário");Esta classe não é anotada e o contêiner não será gerenciado automaticamente. Como não há arquivo de configuração XML, use um como informações de configuração e o arquivo ApplicationCfg.java é o seguinte:
pacote com.zhangguo.spring052.aop05; importar org.springframework.context.annotation.bean; importar org.springframework.context.annotation.ComOnentsCon; Iduration // Classe de configuração usada para representar a classe atual como um contêiner, semelhante ao <Beans/>@componentsCan (BasEpackages = "com.zhangguo.spring052.aop05") // A faixa de varredura é equivalente ao nó da configuração XML <Contexto: Componente-Scan/>@EnableaspectJautoProxy (proxyTargetClass = true) // proxy AUTO/APPLATEF (APPORTF (ASPECTJ-ATOPPROXY APPROTF IGURAÇÃO, equivalente a <ID do bean = getUser/> @Bean Public User getUser () {return New User ();Cada parte desta classe basicamente possui um relacionamento individual com a configuração XML. O código de teste é o seguinte:
pacote com.zhangguo.spring052.aop05; importar org.springframework.context.applicationContext; importar org.springframework.context.annotation.annotationConfigApglicationContext; importação.sPringFramation.CoNontet.SPortLic.clation; ) {// Inicializa os contêineres através da classe ApplicationContext ctx = novo AnnotationConfigApplicationContet (ApplicationCfg.class); = ctx.getBean ("getUser", user.class); conselhos.java é o mesmo que acima, sem nenhuma alteração, o resultado em execução é o seguinte:
O acima é todo o conteúdo deste artigo.