Introdução
A programação orientada orientada (AOP) fornece outra perspectiva para pensar na estrutura do programa, que compensa as deficiências da programação orientada a objetos (OOP). Além das aulas, a AOP fornece facetas. Modularize o foco, como o gerenciamento de transações cruzadas de vários tipos e objetos. (Esses termos preocupados são frequentemente chamados de preocupações transversais.)
Um componente -chave da mola é a estrutura da AOP. Apesar disso, os contêineres do IOC da primavera não confiam na AOP, o que significa que você está livre para escolher se deve usar a AOP. A AOP fornece uma poderosa solução de middleware, o que torna os contêineres do IOC da primavera mais completos.
Spring 2.0 AOP:
A Spring 2.0 apresenta uma maneira mais simples e poderosa de personalizar a seção, e os usuários podem optar por usar métodos baseados em esquema ou usar anotações @aspectj. Para novos aplicativos, se o usuário estiver se desenvolvendo no Java 5, recomendamos que o usuário use o estilo @aspectj, caso contrário, o estilo baseado em padrões pode ser usado. Ambos os estilos suportam totalmente o tipo de conselho e o idioma ponto a corte do aspecto, embora ainda esteja tecendo usando a Spring AOP.
Este capítulo discute principalmente o suporte da Spring 2.0 para a AOP baseada em padrões e @aspecto. Spring 2.0 mantém completamente a compatibilidade com versões anteriores da primavera 1.2. O próximo capítulo discutirá o suporte subjacente à AOP fornecido pela API da primavera 1.2.
AOP usado na primavera:
São fornecidos serviços de empresas declarativas, especialmente no lugar dos serviços declarativos da EJB. O serviço mais importante é o gerenciamento de transações declarativo, que é construído com a abstração da transação abstrata da primavera.
Permite que os usuários implementem seções personalizadas e usem AOP para melhorar o uso do OOP.
Exemplo
Frequentemente usamos os seguintes tipos
1. AOP baseado no agente
2. Facetas de objeto Java puro e simples
3. Formulário de anotação @Aspect
4. Vamos aplicar as seções do ASPCET no formulário de injeção um por uma.
Vamos escrever algumas aulas básicas primeiro.
Classe de interface:
/ *** Defina uma interface*/ interface pública Sleepable {/ *** Método de dormir*/ void Sleep (); } Classe de implementação:
/ *** Implemento a interface do sono*/ classe pública chenllina implementa sono {@Override public void Sleep () {// TODO Method Method Stub System.out.println ("Seja bom, é hora de ir para a cama!"); }} Classe de aprimoramento:
/ *** Defina um aprimoramento do sono para alcançar a classe SleepHelper pré e pós-set*/ pública implementa o método do MethodBeArdvice, após o retorno do {@Override public void após a returning (Método de Retorno de Objeto, Método, Método, Máscara de Objeto, Args, Objeto) lança lança {System.out.println ("Apply Mut Facial } @Override public void Antes (método do método, objeto [] args, objeto alvo) lança throwable {System.out.println ("sonho depois de dormir"); }}1. AOP baseado em agente
<!-Crie um conselho aprimorado-> <bean id = "sleepHelper"/> <bean id = "lina"/> <!-Definir um corte de pontos corresponde a todos os métodos de sono-> <bean id = "sleeppointcut"> <nome da propriedade "padronize". id = "sleepHelPeradvisor"> <propriedade name = "conselhos" ref = "sleepHelper"/> <propriedade name = "pointcut" ref = "sleeppointcut"/> </i bean> <!-define um proxy objeto-> <bean id = "linaproxy"> <nome da propriedade = "alvo" ref = "lina" lina "lina" lina "/> <bean <bean =" linaproxy "> <nome da propriedade =" alvo "" lina "lina" lina "lina" lina "lina"/> <bean = value = "sleepHelPeradvisor"/> <!-<propriedade name = "proxyinterfaces" value = "com.tgb.springaop.service.sleepable"/>-> </i bean>
Como no arquivo de configuração:
O atributo padrão especifica uma expressão regular. Combina todos os métodos de sono. Use org.springframework.aop.support.defaultPointCutadVisor para combinar o ponto tangente e o aprimoramento para formar uma tangente completa. Após a conclusão da configuração final, um objeto final de proxy é gerado através do org.springframework.aop.framework.proxyFactoryBean.
2. Facetas de objeto Java puro e simples
Como dizer essas facetas de objeto Java puramente simples? Na minha opinião, é relativa à primeira configuração, que não requer o uso de um proxy, mas digitaliza automaticamente o mecanismo interno da mola. No momento, nosso arquivo de configuração deve ser modificado da seguinte forma:
<!-Crie um conselho aprimorado-> <bean id = "sleepHelper"/> <!-classe de destino-> <bean id = "lina"/> <!-Configure o corte de pontos e as notificações-> <bean id = "SleepAdvisor"> <Nome da propriedade ". Configuração -> <Bean/>
É muito mais simples que o primeiro? Não há necessidade de configurar mais o proxy?
3. Formulário de anotação @Aspect
Com base em nossa experiência, também sabemos que a forma de anotações é mais simples que o arquivo de configuração. No momento, você precisa comentar sobre métodos ou classes existentes:
/ ***Adicione o aprimoramento por meio da anotação*/ @aspect @Component public class Class SleepHelPer03 {/* @PointCut ("Execution (*com.tgb.springap.service.impl ..*(..))")*/ @PointCUT "ExeCution (*.Sleep (..)")). @Before ("sleeppoint ()") public void beforesleep () {System.out.println ("Aplique máscara facial antes do sono"); } @AfterReturning ("sleeppoint ()") public void depoisSleep () {System.out.println ("sonho depois de dormir"); }
Basta escrever no arquivo de configuração:
<!-pacote de varredura-> <Contexto: component-scan Base-package = "com.tgb" anotação-config = "true"/> <!-ANOTAÇÃO ASCUSTJ-> <AOP: ASCETJ-AUTOPROXY PROXY-TARGET-Class = "True"/> <!-Classe de destino-> <Bean id = "Lina"/>
4. Superfícies de corte de aspcet em forma de injeção
Pessoalmente, sinto que este é o mais simples, mais comumente usado e mais flexível. O arquivo de configuração é o seguinte:
<!-classe de destino-> <bean id = "lina"/> <bean id = "sleepHelper"/> <AOP: config> <aop: aspecto ref = "sleepHelper"> <aOP: antes de method = "beforesLeep" Pointcut = "Execution (*. *.Sleep (..)) "/> </aOP: Aspect> </AOP: config>
A classe SleepHelper02 mencionada no arquivo de configuração é a seguinte:
/ *** Adicione aprimoramento por meio de anotações*/ public class sleepHelper02 {public void beforesleep () {System.out.println ("Aplique uma máscara facial antes de dormir"); } public void depois que é () {System.out.println ("Sonhe depois de dormir"); }}
Parece muito simples? Vocês todos usam a Spring AOP? !
Em relação a como ligar, escrevi várias aulas de teste aqui. Você pode dar uma olhada nisso. Eles são basicamente os mesmos:
/ *** Arquivo de configuração spring_aop.xml via proxy*/ @test public void test () {ApplicationContext ct = new ClassPathXMLApplicationContext ("spring_aop.xml"); Sleepable Sleeper = (Sleepable) Ct.getBean ("LinaProxy"); Sleeper.sleep (); } / *** Arquivo de configuração spring_aop_01.xml Resposta curta Java Objeto* / @Test public void test01 () {ApplicationContext ct = new ClassPathXMLApplicationContext ("spring_aop_01.xml"); Dorminhoco de sono = (sonolento) ct.getBean ("lina"); Sleeper.sleep (); } / *** Arquivo de configuração spring_aop_03.xml anotado por aspecto* / @test public void test03 () {ApplicationContext ct = new ClassPathXMLApplicationContext ("spring_aop_03.xml"); Dorminhoco de sono = (sonolento) ct.getBean ("lina"); Sleeper.sleep (); } / *** Arquivo de configuração Spring_AOP_02.XML Arquivo de configuração através do APSECT* @Author Chen lina* @Version 31 de maio de 2015 às 10:09:37* / @Test public void test02 () {ApplicationContext ct = novo ClassPathXMlApplicationConxt ("_aM. Dorminhoco de sono = (sonolento) ct.getBean ("lina"); Sleeper.sleep (); }
Na classe de teste, podemos ver que, não importa de que maneira implementamos a AOP, o uso deles não é diferente. Os resultados dessas classes de teste são iguais: