0. Sobre aOP
A programação orientada para aspectos (AOP) é um tópico quente no desenvolvimento de software e uma parte importante da estrutura da primavera. 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 é uma continuação do OOP.
As principais funções são: log, estatísticas de desempenho, controle de segurança, processamento de transações, manipulação de exceções, etc.
A principal intenção é dividir os códigos como registro, estatísticas de desempenho, controle de segurança, processamento de transações, manipulação de exceções etc. do código lógico de negócios. Ao separar esses comportamentos, esperamos separá-los em métodos de lógica de negócios não guiantes e alterar esses comportamentos sem afetar o código lógico de negócios.
Uma tecnologia que adiciona dinamicamente funções aos programas sem modificar o código -fonte pode ser alcançada por meio de métodos de pré -compilação e proxy dinâmico durante o tempo de execução. AOP é na verdade uma continuação do modelo de design do GOF. O modelo de design está perseguindo a dissociação entre o chamador e o callee, melhorando a flexibilidade e a escalabilidade do código. Pode -se dizer que a AOP é uma implementação desse objetivo.
Fornece suporte rico para a programação orientada a aspectos na primavera, permitindo o desenvolvimento coesivo, separando a lógica de negócios do aplicativo de serviços no nível do sistema, como auditoria e gerenciamento de transações. Os objetos do aplicativo implementam apenas o que devem fazer - completa a lógica de negócios - é isso. Eles não são responsáveis (ou mesmo cientes de) outras preocupações no nível do sistema, como suporte de registro ou transação.
1. Carregue outros arquivos de configuração externos ou arquivos de propriedade na mola através do PropertyPlaceHoldConfigurer:
Em muitos projetos Javaee, o papel da primavera é muito importante. É um contêiner leve que gerencia outros módulos e componentes. A primavera geralmente precisa gerenciar struts, ibatis, hibernado etc. Os arquivos de configuração dessas estruturas de código aberto são carregadas na primavera através da Spring PropertlePlaceHoldConFigurer for Management. Além disso, as informações de conexão do banco de dados, arquivos de propriedade de informações de conexão JNDI etc. também podem ser carregadas na mola através do PropertyPlaceHoldConFigurer for Management. O uso é o seguinte:
(1). Carregue outros arquivos no Spring através do PropertyPlaceHoldConFigurer:
Adicione a seguinte configuração no arquivo de configuração da mola:
<bean class = "org.springframework.beans.factory.config.propertyplaceholdConfigurer"> <propriedade name = "locations"> <value> ClassPath: Nome do arquivo para carregar
(2). O arquivo de configuração ou atributo a ser carregado através da configuração em (1) é carregado na mola. Se você também precisar usar algumas informações sobre o arquivo de configuração ou dados carregado em tempo de execução, como usar informações de conexão do banco de dados ou informações de conexão JNDI, você pode usar a sintaxe das expressões do tipo EL para referência, por exemplo:
<bean id = "DataSource" Destro-Method = "Close" class = "org.apache.common.dbcp.basicdataSource"> <!-Suponha que as informações de conexão do banco de dados sejam escritas em um arquivo de propriedade externa e foi carregado por mola-> <propriedades "Nome" nome ") e" {}}} e driver "/" <propriedade name = "nome de usuário" value = "$ {nome de usuário}"/> <name da propriedade = "senha" value = "$ {senha}"/> </bean>
NOTA: Você também pode usar <Contexto: Property-PlaceHolderLocation = "ClassPath: Nome do arquivo para carregar"/>
2. Proxy dinâmico para Java:
O princípio de implementação subjacente da Spring é um proxy dinâmico; portanto, você deve primeiro entender o proxy dinâmico antes de aprender a programação orientada a aspectos.
Dynamic proxy is widely used in Java, and dynamic proxy is one of the classic design patterns that are very commonly used in the design patterns in 23. The principle of dynamic proxy is that when a target object or its method is to be called, the system does not directly return the target object, but returns a proxy object, and accesses the target object or method of the target object through this proxy object.
O princípio simples do proxy dinâmico é o seguinte:
Chamador do cliente -> Objeto proxy -> chamado Objeto de destino.
Quando o cliente chama o objeto Proxy, o objeto proxy delega o objeto de destino para chamar seu método de negócios.
O proxy dinâmico é dividido em dois tipos: proxy dinâmico para interfaces e proxy dinâmico para classes comuns. O proxy dinâmico em Java é um proxy dinâmico para interfaces reais. O CGLIB é um proxy dinâmico para classes comuns. O pacote de dependência Javaee de destino e o pacote de jarra de mola já contêm pacotes JAR relacionados ao CGLIB, para que você possa proxie dinamicamente as classes proxy ou comuns.
(1) Proxy dinâmico de Java para interfaces:
O proxy dinâmico em Java só pode ser dinamicamente proxyed para interfaces. Portanto, o objeto de destino deve implementar interfaces e o objeto proxy deve implementar todas as interfaces do objeto de destino. O fluxo de trabalho é o seguinte:
um. Escrita de classe de proxy dinâmica:
Nota: O proxy dinâmico deve implementar a interface InvocationHandler e implementar os seguintes métodos:
A cópia do código é a seguinte:
Objeto Invoke (Instância do proxy ObjectM, Instância do método do método da interface chamado na instância do proxy do método, objeto [] uma matriz de objetos dos valores de parâmetros passados para a instância do proxy);
A documentação para a instalação do JDK é explicada. Este método é usado para passar na instância do proxy, identificar o objeto java.lang.reflect.method que chama o método e uma matriz de parâmetros contendo tipo de objeto. O manipulador de chamadas lida com a chamada do método codificada de maneira apropriada, e o resultado que retorna será retornado como resultado da chamada do método na instância do proxy.
b. Crie um objeto proxy:
Proxy.NewProxyInstance (Class Loader, Class <?> [] Matriz de interface, objeto de proxy de retorno de chamada (geralmente este))
Quando o método do objeto de destino é chamado, o objeto proxy do objeto de destino é criado através do método. O objeto proxy chamará automaticamente seu método Invoke para chamar o objeto de destino e retornar o resultado da chamada.
(2) .Cglib é proxy dinâmica para classes Java comuns:
Quando o CGLIB cria um proxy dinâmico, não exige que a classe de destino implemente uma interface. Seu fluxo de trabalho é o seguinte:
um. Escrita de classe de proxy dinâmica:
Intensificador intensificador = new intensancer (); // Defina a classe pai da classe de destino para seu próprio intensificador.SetSuperclass (classe de destino object.getClass ()); // Defina o objeto de retorno de chamada para o próprio objeto de proxy dinâmico aprimorador.setCallback (this);
b. Implementar a interface do MethodInterceptor:
Implementar o seguinte método:
Intercepto de objeto (instância do proxy ObjectM, instância do método do método da interface chamado no método proxy instância, objeto [] uma matriz de objetos de valores de parâmetros passados para o método chamado na instância do proxy, método de proxy do método Instância de proxy);
NOTA: O CGLIB pode não apenas proxy dinamicamente para classes, mas também proxy dinamicamente para métodos.
3. Conceitos básicos de programação orientada (AOP):
Pegue um método Java comum como exemplo
Nome do método do tipo de retorno público (lista de parâmetros) {―> Método de notificação em torno de pré-processamento Código-> pré-notificação Try {Método Implementação específica (Método Body) ... Código de pós-processamento do método-> Post-Notification} Catch (Tipo de exceção e) {manuseio de exceção ...
um. Preocupação cruzada: por exemplo, nos 5 locais de notificação acima, em objetos Java, esses objetos com lógica de processamento comum semelhante que pode ser adicionada ao processamento da lógica, como verificação de permissão, processamento de coisas, log etc. são chamadas de preocupações cruzadas. O foco da programação orientada a objetos (OOP) é para abstratos verticalmente no mundo real em um modelo de objeto de programação. O foco da programação orientada a aspectos (AOP) é a horizontal, que abstrava os locais semelhantes ao processamento da lógica no modelo de objeto de programação para formar uma tangente, enquanto a lógica de processamento no objeto de programação é o foco tangente horizontal.
b. Aspecto: Abstrair as preocupações cruzadas é formar uma seção, semelhante à classe. Os dois têm preocupações diferentes. As classes são abstrações das características das coisas, e as seções são abstrações de preocupações cruzadas.
c. Jungpoint: O ponto interceptado é referido na primavera, porque a primavera suporta apenas pontos de conexão do tipo método, ou seja, o método interceptado. Método como mostrado no exemplo acima.
d. Pointcut: refere -se à definição de interceptar um ponto de conexão, que é uma coleção de pontos de conexão, ou seja, uma coleção de uma série de métodos interceptados.
e. Conselho: refere -se ao que fazer depois de interceptar o ponto de conexão, ou seja, processamento lógico após interceptar. A verificação usual de permissão, processamento de coisas, registro e outras operações são definidos e concluídos em notificações.
f. Alvo: o objeto de destino do proxy, ou seja, o objeto interceptado. Como no exemplo acima, o objeto em que o método está localizado.
g. TISE: refere -se ao processo de aplicação de uma seção ao objeto de destino e causar a criação de um objeto proxy.
h. Introdução: Sem modificar o código, a introdução pode adicionar dinamicamente alguns métodos e campos à classe durante o tempo de execução.
4. A mola suporta dependências que apóiam a programação orientada para a OP (AOP):
Os três pacotes a seguir no diretório após a primavera são descompactos:
lib/aspectoj/aspectojweaver.jarlib/aspectoj/aspectojrt.jarlib/cglib/cglib-nodep-2.1-3.jar
5. Ao usar a programação orientada a aspectos (AOP) na primavera, você precisa apresentar o espaço para nome da AOP no arquivo de configuração da primavera, ou seja, adicione a seguinte configuração:
xmlns: AOP = ”http://www.springframework.org/schema/aop” “http://www.springframework.org/schema/aop http://www.springframwork.org/schemaop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd ”
Nota: A primavera 2.5 fornece dois métodos AOP, a saber, com base no arquivo de configuração XML e no método de anotação Java.
Para usar o método de anotação AOP, você precisa adicionar o seguinte método de anotação de objeto Suporte AOP no arquivo de configuração da primavera:
<AOP: AspectJ-AutoProxy/>
6. Javabean Packaging Class - Beanwrapper:
A primavera encapsula o comportamento de um Javabean através da classe Beanwrapper e pode definir e obter seus valores de atributo, como:
BEANWRAPER WRAPER CLASS Object = BeanWrapperImpl (nova classe embrulhada ()); Wrapper Class Object.SetPropertyValue ("Nome da propriedade", "Valor da propriedade");
Este método permite definir propriedades para a classe embrulhada.
7. Desenvolvimento de programação orientada a orientação (AOP) com base na anotação:
(1). Adicione o suporte da AOP para métodos de anotação no arquivo de configuração do Spring.
(2). Defina a seção:
Semelhante à criação de uma classe normal, adicionar a anotação "@aspect" antes da classe indica que a classe é uma seção.
(3). Adicione pontos de entrada à superfície cortada:
Um ponto de corte de pontos é uma coleção de métodos de objetos interceptados. Geralmente, o ponto de corte de pontos é definido em um método de processamento do ponto de corte de pontos na seção. Use a anotação "@PointCut", e a sintaxe é a seguinte:
@PointCut ("Execution (*com.test.service ..*.*(..))") public void anymethod () {// O método é chamado de "corte de ponto" e "corte" processamento "}
Explicação detalhada dos parâmetros de sintaxe:
um. O primeiro "*": significa que o método que está sendo interceptado é um tipo de retorno arbitrário.
b. com.test.service: Aqui está um exemplo simples, indicando o nome do pacote a ser interceptado, ou seja, o pacote a ser interceptado.
c. Os dois ".." após o nome do pacote interceptado: significa que os subpackets abaixo do pacote interceptado também são interceptados recursivamente, ou seja, o subpacket interceptado.
d. "*" depois "..": representa todas as classes abaixo do pacote interceptado e sua subpackagem, ou seja, a classe interceptada.
e. O último "*": representa todos os métodos na classe interceptada, ou seja, o método interceptado.
f. "(..)": significa que o método interceptado recebe qualquer parâmetros, ou seja, os parâmetros interceptados.
NOTA: A sintaxe de definição de ponto de corte pode suportar caracteres curinga, mas você deve seguir estritamente as regras de sintaxe. como:
@PointCut ("Execution (*com.test.service ..*. Add*(..))") Isso significa que os métodos de interceptação começando com "Adicionar" em todas as classes no pacote com.test.service e sua subpackagem.
(4). Adicione notificações à seção:
Para locais de notificação na primavera, consulte os pequenos exemplos em 3.
Anotação "@Before": Declare uma pré-notificação.
ANOTAÇÃO "@AFTERRUTRUNING": Declare pós-notificação.
Anotação "@after": Declare o aviso final.
Anotação de "@afterwrowing": Declare a notificação de exceção.
Anotação de "@around": declara notificações circundantes.
Um exemplo de definição de notificações é o seguinte:
@Before ("AnyMethod () (o nome do ponto de entrada declarado na face da fenda)") public void DoaccessCheck () {...}
Nota: A notificação surround é ligeiramente diferente dos outros 4 tipos de notificações. A notificação surround é definida de uma maneira especial. A notificação surround funcionará antes e depois de toda a chamada do método; portanto, o objeto de ponto de conexão deve ser usado para informar o ponto de conexão para continuar seu processamento lógico após o processamento de notificação surround. Sua definição é a seguinte:
@Around (pesquisa no nome do ponto) o objeto público DobasicProfiling (procedingJoinPoint PJP) lança arremesso {... retorna pjp.proeced (); // Esta frase diz ao ponto de conexão para continuar a executar outras operações} 8. Algumas dicas para o desenvolvimento da programação orientada a aspectos (AOP) com base na anotação:
(1). Obtenha parâmetros de entrada:
como:
@Before ("Inscreva o nome do ponto && args (nome do parâmetro de entrada)") public void dosomething (nome do parâmetro de entrada da string) {...}
(2). Obtenha o resultado de retorno:
como:
@AfterReturning (Pointcut = ”Nome do ponto de entrada no ponto”, retornar = ”Nome do resultado do retorno”) public void Dosomething (nome do resultado da string) {…}
9. Desenvolvimento da programação orientada à seção (AOP) com base no XML:
(1). Defina a classe faceta e adicione notificações à classe FACET.
(2). Configure a classe facet no arquivo de configuração da primavera, como a classe Java comum.
(3). Adicione a configuração AOP no arquivo de configuração da mola da seguinte forma:
<AoP: config> <!-Seção de configuração-> <AOP: aspecto id = "seção id" ref = "ID da classe de seção no arquivo de configuração da mola"> <!-Ponto de configuração-> <AOP: Pointcut id = "Seção ID" Expression = "Execution (*com.Test.Service ..*.*. (..)"/>> <-> <! ID "Method =" Métodos de processamento responsáveis na classe de seção "/> <AOP: depois…/>… </aOP: aspecto> </aOP: config>
10. Processamento de transações da primavera (processamento declarativo de transação da primavera):
Simplificando, uma transação refere -se a uma das operações mais básicas no banco de dados. Uma explicação detalhada da transação será explicada em detalhes no resumo relacionado ao banco de dados. Uma das aplicações mais importantes da programação orientada para orientação da Spring (AOP) é o gerenciamento de transações. O gerenciamento de transações da primavera 2.5 e versões posteriores suporta dois tipos de métodos baseados em anotação e métodos baseados em arquivos XML:
(1). Gerenciamento de transações com base no método de anotação:
um. Adicione namespace de gerenciamento de transações no arquivo de configuração da primavera da seguinte forma:
xmlns: ts = http: //www.springframework.org/schema/tx http://www.springframework.org/schema/tx http://www.springframework.org/schema
b. Configure o gerenciador de transações no arquivo de configuração da primavera da seguinte forma:
<bean id = "txManager" class = "org.springframework.jdbc.dataSource.dataSourceTransactionManager"> <propriedade name = "DataSource" Ref = "Id da fonte de dados Bean configurada na primavera"/>
c. Adicionar itens de configuração de transação que suportam métodos de anotação no arquivo de configuração da mola são os seguintes:
<tx: anotação-driventransaction-manager-tx: anotação-driventransaction-manager = ”TXManager (ID do gerente de transação Bean configurado na primavera)”/>
d. Use o gerenciamento de transações baseado em anotação:
No projeto Javaee gerenciado pela primavera, a lógica de negócios da transação precisa ser adicionada à anotação "@Transactional".
(2). Gerenciamento de transações com base no método de arquivo XML:
um. Configure o gerenciador de transações no arquivo de configuração da primavera da seguinte forma:
<bean id = "txManager" class = "org.springframework.jdbc.dataSource.dataSourceTransactionManager"> <propriedade name = "DataSource" Ref = "Id da fonte de dados Bean configurada na primavera"/>
b. Adicione as seguintes seções de gerenciamento de coisas no arquivo de configuração da primavera:
<AoP: config> <!-Configurar ponto de entrada da transação-> <AOP: Pointcut id = "transactionPointCut" Expression = "Execution (*com.test.service ..*.*(..))"/> <!-Configure Notification-> <AOP: Advisor Advice-Ref = "" TXadVice "c. Adicione os seguintes recursos para notificações de transação no arquivo de configuração da primavera:
<tx: conselhos id = "txadvice" transactionManager = "txManager"> <tx: atributes> <!-Aqui está um exemplo para definir o método de consulta que começa com a leitura somente e não suporta transações-> <tx: nome do método = "get*" read-inly = "" propagation = "não _support" nome = ”*”/> </tx: atributos> </tx: conselhos>