Spring AOP - Guia rápido

Um dos principais componentes do Spring Framework é o Aspect Oriented Programming (AOP)estrutura. A Programação Orientada a Aspectos envolve quebrar a lógica do programa em partes distintas chamadasso-called concerns. As funções que abrangem vários pontos de um aplicativo são chamadas de interesses transversais. Estescross-cutting concernssão conceitualmente separados da lógica de negócios do aplicativo. Existem vários bons exemplos comuns de aspectos como registro, auditoria, transações declarativas, segurança, armazenamento em cache, etc.

A principal unidade de modularidade em OOP é a classe, enquanto em AOP a unidade de modularidade é o aspecto. A injeção de dependência ajuda a desacoplar seus objetos de aplicativo uns dos outros, enquanto o AOP ajuda a desacoplar interesses transversais dos objetos que eles afetam. AOP é como gatilhos em linguagens de programação como Perl, .NET, Java e outras.

O módulo Spring AOP permite que os interceptores interceptem um aplicativo. Por exemplo, quando um método é executado, você pode adicionar funcionalidade extra antes ou depois da execução do método.

Este capítulo o conduz pelo processo de configuração do Spring AOP em sistemas baseados em Windows e Linux. O Spring AOP pode ser facilmente instalado e integrado ao seu ambiente Java e MAVEN atual, seguindo algumas etapas simples sem quaisquer procedimentos de configuração complexos. A administração do usuário é necessária durante a instalação.

Requisitos de sistema

JDK	Java SE 2 JDK 1.5 ou superior
Memória	1 GB de RAM (recomendado)
Espaço em disco	Sem requisitos mínimos
Versão do sistema operacional	Windows XP ou superior, Linux

Vamos agora dar uma olhada nas etapas para instalar o Spring AOP.

Etapa 1: verifique a instalação do Java

Em primeiro lugar, você precisa ter o Java Software Development Kit (SDK) instalado em seu sistema. Para verificar isso, execute qualquer um dos dois comandos a seguir, dependendo da plataforma em que está trabalhando.

Se a instalação do Java foi feita corretamente, ele exibirá a versão atual e as especificações de sua instalação do Java. Um exemplo de saída é fornecido na tabela a seguir.

Plataforma	Comando	Saída de amostra
janelas	Abra o console de comando e digite - \>java -version	Versão Java "1.7.0_60" Java (TM) SE Run Time Environment (build 1.7.0_60-b19) Java Hotspot (TM) Servidor VM de 64 bits (versão 24.60-b09, modo misto)
Linux	Abra o terminal de comando e digite - $java -version	versão java "1.7.0_25" Open JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64) Abra o servidor VM JDK de 64 bits (compilação 23.7-b01, modo misto)

Presumimos que os leitores deste tutorial tenham o Java SDK versão 1.7.0_60 instalado em seus sistemas.

Caso você não tenha Java SDK, baixe sua versão atual em https://www.oracle.com/technetwork/java/javase/downloads/index.html e instalá-lo.

Etapa 2: definir seu ambiente Java

Defina a variável de ambiente JAVA_HOME para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo,

Sr. Não.	Plataforma e descrição
1	Windows Defina JAVA_HOME como C: \ ProgramFiles \ java \ jdk1.7.0_60
2	Linux Exportar JAVA_HOME = / usr / local / java-current

Anexe o caminho completo do local do compilador Java ao caminho do sistema.

Sr. Não.	Plataforma e descrição
1	Windows Anexe a string "C: \ Arquivos de programas \ Java \ jdk1.7.0_60 \ bin" ao final do caminho da variável do sistema.
2	Linux Exportar PATH = $ PATH: $ JAVA_HOME / bin /

Execute o comando java -version no prompt de comando, conforme explicado acima.

Etapa 3: Baixe o arquivo Maven

Baixe o Maven 3.3.3 de https://maven.apache.org/download.cgi

SO	Nome do Arquivo
janelas	apache-maven-3.3.3-bin.zip
Linux	apache-maven-3.3.3-bin.tar.gz
Mac	apache-maven-3.3.3-bin.tar.gz

Etapa 4: Extraia o arquivo Maven

Extraia o arquivo para o diretório em que deseja instalar o Maven 3.3.3. O subdiretório apache-maven-3.3.3 será criado a partir do arquivo.

SO	Localização (pode ser diferente com base na sua instalação)
janelas	C: \ Arquivos de programas \ Apache Software Foundation \ apache-maven-3.3.3
Linux	/ usr / local / apache-maven
Mac	/ usr / local / apache-maven

Etapa 5: definir as variáveis de ambiente Maven

Adicione M2_HOME, M2, MAVEN_OPTS às variáveis de ambiente.

SO	Resultado
janelas	Defina as variáveis de ambiente usando propriedades do sistema. M2_HOME = C: \ Arquivos de programas \ Apache Software Foundation \ apache-maven-3.3.3 M2 =% M2_HOME% \ bin MAVEN_OPTS = -Xms256m -Xmx512m
Linux	Abra o terminal de comando e defina as variáveis de ambiente. export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 exportar M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m
Mac	Abra o terminal de comando e defina as variáveis de ambiente. export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 exportar M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m

Etapa 6: adicionar localização do diretório Bin Maven ao caminho do sistema

Agora anexe a variável M2 ao caminho do sistema.

SO	Resultado
janelas	Anexe a string;% M2% ao final da variável do sistema, Caminho.
Linux	exportar PATH = $ M2: $ PATH
Mac	exportar PATH = $ M2: $ PATH

Etapa 7: verificar a instalação do Maven

Agora abra o console e execute o seguinte mvn comando.

SO	Tarefa	Comando
janelas	Abrir console de comando	c: \> mvn --version
Linux	Abra o terminal de comando	$ mvn --version
Mac	Terminal aberto	máquina: <joseph $ mvn --version

Finalmente, verifique a saída dos comandos acima, que devem ser algo como a seguir -

SO	Resultado
janelas	Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Página inicial do Maven: C: \ Arquivos de programas \ Apache Software Foundation \ apache-maven-3.3.3 Versão Java: 1.7.0_75, fornecedor: Oracle Corporation Página inicial do Java: C: \ Arquivos de programas \ Java \ jdk1.7.0_75 \ jre Localidade padrão: en_US, codificação de plataforma: Cp1252
Linux	Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Página inicial do Maven: /usr/local/apache-maven/apache-maven-3.3.3 Versão Java: 1.7.0_75, fornecedor: Oracle Corporation Página inicial do Java: /usr/local/java-current/jdk1.7.0_75/jre
Mac	Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Página inicial do Maven: /usr/local/apache-maven/apache-maven-3.3.3 Versão Java: 1.7.0_75, fornecedor: Oracle Corporation Página inicial do Java: /Library/Java/Home/jdk1.7.0_75/jre

Etapa 8 - Configurar IDE Eclipse

Todos os exemplos neste tutorial foram escritos usando Eclipse IDE. Portanto, eu sugiro que você tenha a versão mais recente do Eclipse instalada em sua máquina.

Para instalar o Eclipse IDE, baixe os binários mais recentes do Eclipse em https://www.eclipse.org/downloads/. Depois de baixar a instalação, descompacte a distribuição binária em um local conveniente. Por exemplo, em C: \ eclipse no Windows ou / usr / local / eclipse no Linux / Unix e, finalmente, defina a variável PATH apropriadamente.

O Eclipse pode ser iniciado executando os seguintes comandos na máquina Windows ou você pode clicar duas vezes em eclipse.exe

%C:\eclipse\eclipse.exe

O Eclipse pode ser iniciado executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.) -

$/usr/local/eclipse/eclipse

Após uma inicialização bem-sucedida, se tudo estiver bem, ele deve exibir o seguinte resultado -

Depois de concluir esta última etapa, você está pronto para prosseguir para o seu primeiro exemplo de AOP, que verá no próximo capítulo.

Antes de começarmos a trabalhar com AOP, vamos nos familiarizar com os conceitos e terminologias de AOP. Esses termos não são específicos do Spring, mas estão relacionados ao AOP.

Sr. Não.	Termos e Descrição
1	Aspect Um módulo que possui um conjunto de APIs que fornecem requisitos transversais. Por exemplo, um módulo de registro seria chamado de aspecto AOP para registro. Um aplicativo pode ter vários aspectos, dependendo do requisito.
2	Join point Isso representa um ponto em seu aplicativo onde você pode inserir o aspecto AOP. Você também pode dizer que é o lugar real no aplicativo onde uma ação será realizada usando a estrutura Spring AOP.
3	Advice Esta é a ação real a ser realizada antes ou depois da execução do método. Esta é a parte real do código que é invocada durante a execução do programa pelo framework Spring AOP.
4	PointCut Este é um conjunto de um ou mais pontos de junção onde um conselho deve ser executado. Você pode especificar PointCuts usando expressões ou padrões, como veremos em nossos exemplos de AOP.
5	Introduction Uma introdução permite adicionar novos métodos ou atributos às classes existentes.
6	Target object O objeto sendo aconselhado por um ou mais aspectos. Este objeto sempre será um objeto proxy. Também conhecido como objeto aconselhado.
7	Weaving Tecelagem é o processo de vincular aspectos a outros tipos de aplicativos ou objetos para criar um objeto recomendado. Isso pode ser feito em tempo de compilação, tempo de carregamento ou tempo de execução.

Os aspectos da mola podem funcionar com cinco tipos de conselhos mencionados na tabela a seguir.

Sr. Não.	Conselhos e descrição
1	before Execute o conselho antes da execução do método.
2	after Execute o conselho após a execução do método, independentemente de seu resultado.
3	after-returning Execute o conselho após a execução do método, apenas se o método for concluído com êxito.
4	after-throwing Execute o conselho após a execução do método, apenas se o método for encerrado lançando uma exceção.
5	around Execute o conselho antes e depois de invocar o método recomendado.

Spring apóia o @AspectJ annotation style abordagem e o schema-based abordagem para implementar aspectos personalizados.

Com base em esquema XML

Aspectos são implementados usando classes regulares junto com configuração baseada em XML.

Para usar as tags de namespace AOP descritas nesta seção, você precisa importar o esquema AOP spring, descrito a seguir -

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <!-- bean definition & AOP specific configuration -->

</beans>

Declarando um Aspecto

A aspect é declarado usando o <aop:aspect> elemento, e o bean de apoio é referenciado usando o ref atributo da seguinte forma.

<aop:config>
   <aop:aspect id = "myAspect" ref = "aBean">
   ...
   </aop:aspect>
</aop:config>

<bean id = "aBean" class = "...">
   ...
</bean>

Aqui, "aBean" será configurado e a dependência injetada como qualquer outro bean Spring, como você viu nos capítulos anteriores.

Declarando um PointCut

UMA PointCutajuda a determinar os pontos de junção (ou seja, métodos) de interesse a serem executados com diferentes conselhos. Ao trabalhar com a configuração baseada no esquema XML, PointCut será definido da seguinte forma -

<aop:config>
   <aop:aspect id = "myAspect" ref = "aBean">

   <aop:PointCut id = "businessService"
      expression = "execution(* com.xyz.myapp.service.*.*(..))"/>
      ...
   </aop:aspect>
</aop:config>

<bean id = "aBean" class = "...">
   ...
</bean>

O exemplo a seguir define um PointCut denominado 'businessService' que corresponderá à execução do método getName () disponível na classe Aluno no pacote com.tutorialspoint.

<aop:config>
   <aop:aspect id = "myAspect" ref = "aBean">

   <aop:PointCut id = "businessService"
      expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
   ...
   </aop:aspect>
</aop:config>

<bean id = "aBean" class = "...">
   ...
</bean>

Declarando Conselhos

Você pode declarar qualquer um dos cinco conselhos dentro de um <aop: aspect> usando o elemento <aop: {ADVICE NAME}> como segue.

<aop:config>
   <aop:aspect id = "myAspect" ref = "aBean">
      <aop:PointCut id = "businessService"
         expression = "execution(* com.xyz.myapp.service.*.*(..))"/>

      <!-- a before advice definition -->
      <aop:before PointCut-ref = "businessService" 
         method = "doRequiredTask"/>

      <!-- an after advice definition -->
      <aop:after PointCut-ref = "businessService" 
         method = "doRequiredTask"/>

      <!-- an after-returning advice definition -->
      <!--The doRequiredTask method must have parameter named retVal -->
      <aop:after-returning PointCut-ref = "businessService"
         returning = "retVal"
         method = "doRequiredTask"/>

      <!-- an after-throwing advice definition -->
      <!--The doRequiredTask method must have parameter named ex -->
      <aop:after-throwing PointCut-ref = "businessService"
        throwing = "ex"
         method = "doRequiredTask"/>

      <!-- an around advice definition -->
      <aop:around PointCut-ref = "businessService" 
         method = "doRequiredTask"/>
   ...
   </aop:aspect>
</aop:config>

<bean id = "aBean" class = "...">
   ...
</bean>

Você pode usar o mesmo doRequiredTaskou métodos diferentes para conselhos diferentes. Esses métodos serão definidos como parte do módulo de aspecto.

Baseado em @AspectJ

@AspectJ refere-se a um estilo de declaração de aspectos como classes Java regulares anotadas com anotações Java 5. O suporte @AspectJ é habilitado incluindo o seguinte elemento dentro de seu arquivo de configuração baseado em esquema XML.

<aop:aspectj-autoproxy/>

Declarando um Aspecto

As classes de aspectos são como qualquer outro bean normal e podem ter métodos e campos como qualquer outra classe, exceto que eles serão anotados com @Aspect como segue.

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AspectModule {

}

Eles serão configurados em XML como qualquer outro bean da seguinte maneira.

<bean id = "myAspect" class = "org.xyz.AspectModule">
   <!-- configure properties of aspect here as normal -->
</bean>

Declarando um PointCut

UMA PointCutajuda a determinar os pontos de junção (ou seja, métodos) de interesse a serem executados com diferentes conselhos. Ao trabalhar com a configuração baseada em @AspectJ, a declaração PointCut tem duas partes -

Uma expressão PointCut que determina exatamente em quais execuções de método estamos interessados.
Uma assinatura PointCut que compreende um nome e qualquer número de parâmetros. O corpo real do método é irrelevante e, na verdade, deveria estar vazio.

O exemplo a seguir define um PointCut denominado 'businessService' que corresponderá à execução de cada método disponível nas classes sob o pacote com.xyz.myapp.service.

import org.aspectj.lang.annotation.PointCut;

@PointCut("execution(* com.xyz.myapp.service.*.*(..))") // expression 
private void businessService() {}  // signature

O exemplo a seguir define um PointCut denominado 'getname' que corresponderá à execução do método getName () disponível na classe Student no pacote com.tutorialspoint.

import org.aspectj.lang.annotation.PointCut;

@PointCut("execution(* com.tutorialspoint.Student.getName(..))") 
private void getname() {}

Declarando Conselhos

Você pode declarar qualquer um dos cinco avisos usando as anotações @ {ADVICE-NAME} conforme fornecido abaixo. Isso pressupõe que você já definiu um método de assinatura PointCut businessService ().

@Before("businessService()")
public void doBeforeTask(){
   ...
}

@After("businessService()")
public void doAfterTask(){
   ...
}

@AfterReturning(PointCut = "businessService()", returning = "retVal")
public void doAfterReturnningTask(Object retVal){
   // you can intercept retVal here.
   ...
}

@AfterThrowing(PointCut = "businessService()", throwing = "ex")
public void doAfterThrowingTask(Exception ex){
   // you can intercept thrown exception here.
   ...
}

@Around("businessService()")
public void doAroundTask(){
   ...
}

Você pode definir PointCut embutido para qualquer um dos conselhos. A seguir está um exemplo para definir PointCut embutido para aconselhamento prévio.

@Before("execution(* com.xyz.myapp.service.*.*(..))")
public doBeforeTask(){
   ...
}

Neste capítulo, iremos escrever aplicações AOP reais usando Spring AOP Framework. Antes de começar a escrever seu primeiro exemplo usando a estrutura Spring-WS, você deve se certificar de que configurou seu ambiente Spring AOP corretamente, conforme explicado no capítulo Spring Web Services - Configuração de Ambiente .

Agora, prossiga para escrever um aplicativo Spring AOP simples com console, que demonstrará os conceitos de AOP.

Crie um Projeto

Step 1 - Abra um console de comando, vá para o diretório C: \ MVN e execute o seguinte mvn comando.

C:\MVN>mvn archetype:generate -DgroupId = com.tutorialspoint -DartifactId = Student
	-DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = false

O Maven iniciará o processamento e criará a estrutura completa do projeto do aplicativo Java.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.4:generate (default-cli) > generate-sources
@ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.4:generate (default-cli) < generate-sources
@ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.4:generate (default-cli) @ standalone-pom --
-
[INFO] Generating project in Batch mode
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar (5 KB at 1.1 KB/s
ec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom (703 B at 1.2 KB/
sec)
[INFO] -------------------------------------------------------------------------
---
[INFO] Using following parameters for creating project from Old (1.x) Archetype:
 maven-archetype-quickstart:1.0
[INFO] -------------------------------------------------------------------------
---
[INFO] Parameter: groupId, Value: com.tutorialspoint
[INFO] Parameter: packageName, Value: com.tutorialspoint
[INFO] Parameter: package, Value: com.tutorialspoint
[INFO] Parameter: artifactId, Value: Student
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\Student
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 01:17 min
[INFO] Finished at: 2017-02-19T21:11:14+05:30
[INFO] Final Memory: 15M/114M
[INFO] ------------------------------------------------------------------------

Step 2- Vá para o diretório C: / MVN. Você verá um projeto de aplicativo Java criado, denominado student (conforme especificado em artifactId). Atualize o POM.xml para incluir dependências Spring-AOP. Adicione os arquivos MainApp.java, Student.java e Logging.java.

POM.xml

<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 
   http://maven.apache.org/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>Student</artifactId>
   <packaging>jar</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>Student</name>
   <url>http://maven.apache.org</url>
   
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>4.1.0.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>4.1.4.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.6.8</version>
      </dependency>
      
   </dependencies>
</project>
package com.tutorialspoint;

public class Logging {

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   public void beforeAdvice() {
      System.out.println("Going to setup student profile.");
   }

   /** 
    * This is the method which I would like to execute
    * after a selected method execution.
    */
   public void afterAdvice() {
      System.out.println("Student profile has been setup.");
   }

   /** 
    * This is the method which I would like to execute
    * when any method returns.
    */
   public void afterReturningAdvice(Object retVal){
      System.out.println("Returning:" + retVal.toString() );
   }

   /**
    * This is the method which I would like to execute
    * if there is an exception raised.
    */
   public void AfterThrowingAdvice(IllegalArgumentException ex) {
      System.out.println("There has been an exception: " + ex.toString());   
   }
   
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();
      
      student.printThrowException();
   }
}

Step 3 - Adicione o arquivo de configuração Beans.xml debaixo src > main > resources pasta.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
            expression = "execution(* com.tutorialspoint.*.*(..))"/>
         <aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>
         <aop:after PointCut-ref = "selectAll" method = "afterAdvice"/>
         <aop:after-returning PointCut-ref = "selectAll" 
            returning = "retVal"
            method = "afterReturningAdvice"/>
         <aop:after-throwing PointCut-ref = "selectAll" 
           throwing = "ex"
            method = "AfterThrowingAdvice"/>
      </aop:aspect>
   </aop:config>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Step 4 - Abra o console de comando, vá para o diretório C: \ MVN e execute o seguinte mvn comando.

C:\MVN>Student> mvn package

O Maven iniciará o processamento e o download das bibliotecas necessárias.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Student 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven
-jar-plugin/2.4/maven-jar-plugin-2.4.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-
jar-plugin/2.4/maven-jar-plugin-2.4.pom (6 KB at 2.2 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven
-jar-plugin/2.4/maven-jar-plugin-2.4.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-
jar-plugin/2.4/maven-jar-plugin-2.4.jar (34 KB at 31.6 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-aop
/4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-aop/
4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.pom (3 KB at 3.7 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-bea
ns/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-bean
s/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.pom (3 KB at 4.1 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-cor
e/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-core
/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.pom (3 KB at 4.0 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-aop
/4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.jar
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-cor
e/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.jar
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-bea
ns/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.jar
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-aop/
4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.jar (351 KB at 43.9 KB/sec)
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-bean
s/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.jar (685 KB at 37.5 KB/sec)
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-core
/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.jar (982 KB at 47.1 KB/sec)
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ Student --
-
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\Student\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ Student ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\Student\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ St
udent ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\Student\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ Student
 ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\Student\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ Student ---
[INFO] Surefire report directory: C:\MVN\Student\target\surefire-reports
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/sure
fire-junit3/2.12.4/surefire-junit3-2.12.4.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/suref
ire-junit3/2.12.4/surefire-junit3-2.12.4.pom (2 KB at 1.3 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/sure
fire-junit3/2.12.4/surefire-junit3-2.12.4.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/suref
ire-junit3/2.12.4/surefire-junit3-2.12.4.jar (26 KB at 27.7 KB/sec)

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.tutorialspoint.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.002 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ Student ---
Downloading: https://repo.maven.apache.org/maven2/classworlds/classworlds/1.1-al
pha-2/classworlds-1.1-alpha-2.jar
Downloaded: https://repo.maven.apache.org/maven2/classworlds/classworlds/1.1-alp
ha-2/classworlds-1.1-alpha-2.jar (37 KB at 35.8 KB/sec)
[INFO] Building jar: C:\MVN\Student\target\Student-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 38.441 s
[INFO] Finished at: 2017-02-19T21:18:59+05:30
[INFO] Final Memory: 18M/109M
[INFO] ------------------------------------------------------------------------

Importar projeto no Eclipse

Step 1 - Abra o Eclipse.

Step 2 - Selecione File → Import → opção.

Step 3- Selecione a opção de projetos Maven. Clique no botão Próximo.

Step 4 - Selecione o local do projeto, onde o projeto do aluno foi criado usando o Maven.

Step 5 - Clique no botão Concluir.

Executar projeto

Depois de criar os arquivos de origem e configuração, execute seu aplicativo. Clique com o botão direito em MainApp.java em seu aplicativo e userun as Java Applicationcomando. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.

Going to setup student profile.
Name : Zara
Student profile has been setup.
Returning:Zara
Going to setup student profile.
Age : 11
Student profile has been setup.
Returning:11
Going to setup student profile.
Exception raised
Student profile has been setup.
There has been an exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException
   at com.tutorialspoint.Student.printThrowException(Student.java:25)
   
   at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>)
   
   at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
   
   at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:52) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:43) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:52) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
   
   at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$56a970f2.printThrowException(<generated>)
   
   at com.tutorialspoint.MainApp.main(MainApp.java:16)

Ponto de junção

Um JoinPoint representa um ponto em seu aplicativo onde você pode inserir o aspecto AOP. Você também pode dizer que é o lugar real no aplicativo onde uma ação será realizada usando a estrutura Spring AOP. Considere os seguintes exemplos -

Todas as classes de métodos contidas em um (s) pacote (s).
Métodos específicos de uma classe.

PointCut

PointCut é um conjunto de um ou mais JoinPoints onde um conselho deve ser executado. Você pode especificar PointCuts usando expressões ou padrões, como veremos em nossos exemplos de AOP. Na primavera, PointCut ajuda a usar JoinPoints específicos para aplicar o conselho. Considere os seguintes exemplos -

expressão = "execução (* com.tutorialspoint. *. * (..))"
expressão = "execução (* com.tutorialspoint.Student.getName (..))"

Sintaxe

<aop:config>
   <aop:aspect id = "log" ref = "adviceClass">
      <aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>    
   </aop:aspect>
</aop:config>

Onde,

adviceClass - ref da classe contendo métodos de aconselhamento
PointCut-id - id do PointCut
execution( expression ) - Expressão cobrindo métodos nos quais o conselho deve ser aplicado.

Para entender os conceitos mencionados acima relacionados a JoinPoint e PointCut, vamos escrever um exemplo que implementará alguns dos PointCuts. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

public class Logging {

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }   
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
         expression = "execution(* com.tutorialspoint.*.*(..))"/>
         <aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>         
      </aop:aspect>
   </aop:config>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Quando terminar de criar os arquivos de configuração de origem e bean, execute o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.

Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11

O <aop: pointcut> definido acima seleciona todos os métodos definidos no pacote com.tutorialspoint. Suponhamos que você queira executar seu conselho antes ou depois de um método específico, você pode definir seu PointCut para restringir sua execução substituindo as estrelas (*) na definição de PointCut por nomes de classe e métodos reais. A seguir está um arquivo de configuração XML modificado para mostrar o conceito.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
            expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
         <aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>
      </aop:aspect>
   </aop:config>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Going to setup student profile.
Name : Zara
Age : 11

Beforeé um tipo de conselho que garante que um conselho seja executado antes da execução do método. A seguir está a sintaxe do conselho prévio.

Sintaxe

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>    
      <aop:before PointCut-ref = "PointCut-id" method = "methodName"/>
   </aop:aspect>
</aop:config>

Onde,

PointCut-id - id do PointCut.
methodName - Nome do método da função a ser chamada antes de uma função chamada.

Para entender os conceitos mencionados acima relacionados ao Antes do Conselho, vamos escrever um exemplo, que implementará o Antes do Conselho. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

public class Logging {

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }   
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
            expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
         <aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>
      </aop:aspect>
   </aop:config>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Going to setup student profile.
Name : Zara
Age : 11

Afteré um tipo de conselho que garante que um conselho seja executado após a execução do método. A seguir está a sintaxe do conselho posterior.

Sintaxe

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>    
      <aop:after PointCut-ref = "PointCut-id" method = "methodName"/>
   </aop:aspect>
</aop:config>

Onde,

PointCut-id - id do PointCut.
methodName - Nome do método da função a ser chamada após uma função chamada.

Para entender os conceitos mencionados acima relacionados ao After Advice, vamos escrever um exemplo que implementará o After Advice. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

public class Logging {

   /** 
    * This is the method which I would like to execute
    * after a selected method execution.
    */
   public void afterAdvice(){
      System.out.println("Student profile setup complete.");
   }   
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
            expression = "execution(* com.tutorialspoint.Student.getAge(..))"/>
         <aop:after PointCut-ref = "selectAll" method = "afterAdvice"/>
      </aop:aspect>
   </aop:config>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Name : Zara
Age : 11
Student profile setup complete.

Afteré um tipo de conselho que garante que um conselho seja executado após a execução do método apenas se o método for concluído com êxito. A seguir está a sintaxe do conselho posterior.

Sintaxe

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>    
      <aop:after-returning PointCut-ref = "PointCut-id" 
         returning = "retVal" method = "methodName"/>
   </aop:aspect>
</aop:config>

Onde,

PointCut-id - id do PointCut.
methodName - Nome do método da função a ser chamada depois que uma função chamada retorna com sucesso.

Para entender os conceitos mencionados acima relacionados ao Conselho Após Retornar, vamos escrever um exemplo que implementará o conselho Após Retornar. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring -

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

public class Logging {

   /** 
    * This is the method which I would like to execute
    * when any method returns.
    */
   public void afterReturningAdvice(Object retVal){
      System.out.println("Returning:" + retVal.toString() );
   }
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
         expression = "execution(* com.tutorialspoint.*.*(..))"/>
         <aop:after-returning PointCut-ref = "selectAll" 
            method = "afterReturningAdvice" returning = "retVal"/>         
      </aop:aspect>
   </aop:config>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Name : Zara
Returning : Name
Age : 11
Exception raised

After-throwingé um tipo de conselho que garante que um conselho seja executado após a execução do método, somente se o método for encerrado lançando uma exceção. A seguir está a sintaxe do conselho após o lançamento.

Sintaxe

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>    
      <aop:after-throwing PointCut-ref = "PointCut-id" throwing = "ex" 
         method = "methodName"/>
   </aop:aspect>
</aop:config>

Onde,

PointCut-id - id do PointCut.
ex - Exceção a ser lançada.
methodName - Nome do método da função a ser chamada quando uma função chamada lança uma exceção e sai.

Para entender os conceitos mencionados acima relacionados ao Conselho após o lançamento, vamos escrever um exemplo que implementará o Conselho após o lançamento. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring -

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

public class Logging {
   /**
    * This is the method which I would like to execute
    * if there is an exception raised.
    */
   public void afterThrowingAdvice(IllegalArgumentException ex) {
      System.out.println("There has been an exception: " + ex.toString());   
   } 
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      System.out.println("Age : " + age );
	  return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.printThrowException();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
         expression = "execution(* com.tutorialspoint.*.*(..))"/>
         <aop:after-throwing PointCut-ref = "selectAll" 
            throwing = "ex" method = "afterThrowingAdvice"/>         
      </aop:aspect>
   </aop:config>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Exception raised
There has been an exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException
   at com.tutorialspoint.Student.printThrowException(Student.java:25)
	
   at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>>)
	
   at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
	
   at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
	
   at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$8514cd8.printThrowException(<generated>)
	
   at com.tutorialspoint.MainApp.main(MainApp.java:15)

Aroundé um tipo de conselho que garante que um conselho seja executado antes e depois da execução do método. A seguir está a sintaxe do conselho.

Sintaxe

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>    
      <aop:around PointCut-ref = "PointCut-id" method = "methodName"/>
   </aop:aspect>
</aop:config>

Onde,

PointCut-id - id do PointCut.
methodName - Nome do método da função a ser chamada antes de uma função chamada.

Para entender os conceitos mencionados acima relacionados ao Around Advice, vamos escrever um exemplo que implementará Around Advice. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring -

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class Logging {

   /** 
    * This is the method which I would like to execute
    * around a selected method execution.
    */
   public String aroundAdvice(ProceedingJoinPoint jp) throws Throwable{
      System.out.println("Around advice");
      Object[] args = jp.getArgs();
      if(args.length>0){
         System.out.print("Arguments passed: " );
         for (int i = 0; i < args.length; i++) {
            System.out.print("arg "+(i+1)+": "+args[i]);
         }
      }

      Object result = jp.proceed(args);
      System.out.println("Returning " + result);
      return result.toString();
   }   
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();    
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectName" 
            expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
         <aop:around PointCut-ref = "selectName" method = "aroundAdvice"/>
      </aop:aspect>
   </aop:config>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Around advice
Name : Zara
Returning Zara

Vamos escrever um exemplo que implementará conselhos usando a configuração baseada em anotação. Para isso, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.PointCut;

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.*.*(..))")
   private void selectAll(){}

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   @Before("selectAll()")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }  
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();   
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11

JoinPoint

Todas as classes de métodos contidas em um (s) pacote (s).
Métodos específicos de uma classe.

PointCut

PointCut é um conjunto de um ou mais JoinPoint onde um conselho deve ser executado. Você pode especificar PointCuts usando expressões ou padrões, como veremos em nossos exemplos de AOP. Na primavera, PointCut ajuda a usar JoinPoints específicos para aplicar o conselho. Considere os seguintes exemplos -

@PointCut ("execução (* com.tutorialspoint. *. * (..))")
@PointCut ("execução (* com.tutorialspoint.Student.getName (..))")

Sintaxe

@Aspect
public class Logging {

   @PointCut("execution(* com.tutorialspoint.*.*(..))")
   private void selectAll(){}

}

Onde,

@Aspect - Marque uma classe como uma classe que contém métodos de aconselhamento.
@PointCut - Marque uma função como PointCut
execution( expression ) - Expressão cobrindo métodos nos quais o conselho deve ser aplicado.

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Before;

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.*.*(..))")
   private void selectAll(){}

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   @Before("selectAll()")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }  
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11

O @Pointcut definido acima usa uma expressão para selecionar todos os métodos definidos no pacote com.tutorialspoint. O conselho @Before usa o PointCut definido acima como um parâmetro. Efetivamente, o método beforeAdvice () será chamado antes de cada método coberto pelo PointCut acima.

@Beforeé um tipo de conselho que garante que um conselho seja executado antes da execução do método. A seguir está a sintaxe do conselho @Before.

Sintaxe

@PointCut("execution(* com.tutorialspoint.Student.getName(..))")
private void selectGetName(){}

@Before("selectGetName()")
public void beforeAdvice(){
   System.out.println("Going to setup student profile.");
}

Onde,

@PointCut - Marque uma função como PointCut
execution( expression ) - Expressão cobrindo métodos nos quais o conselho deve ser aplicado.
@Before - Marque uma função como um conselho a ser executado antes dos métodos cobertos pelo PointCut.

Para entender os conceitos mencionados acima relacionados ao @Before Advice, vamos escrever um exemplo que implementará @Before Advice. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring -

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Before;

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.Student.getName(..))")
   private void selectGetName(){}

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   @Before("selectGetName()")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }  
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Going to setup student profile.
Name : Zara
Age : 11

O @Pointcut definido acima usa uma expressão para selecionar o método getAge () definido na (s) classe (s) sob o pacote com.tutorialspoint. @Após o conselho usa o PointCut definido acima como um parâmetro. Efetivamente, o método afterAdvice () será chamado antes de cada método coberto pelo PointCut acima.

@Afteré um tipo de conselho que garante que um conselho seja executado após a execução do método. A seguir está a sintaxe do conselho @After.

Sintaxe

@PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetName(){}

@After("selectGetAge()")
public void afterAdvice(){
   System.out.println("Student profile setup completed.");
}

Onde,

@PointCut - Marque uma função como PointCut
execution( expression ) - Expressão cobrindo métodos nos quais o conselho deve ser aplicado.
@After - Marque uma função como um conselho a ser executado antes dos métodos cobertos pelo PointCut.

Para entender os conceitos mencionados acima relacionados ao @After Advice, vamos escrever um exemplo que implementará @After Advice. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.After;

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
   private void selectGetAge(){}

   /** 
    * This is the method which I would like to execute
    * after a selected method execution.
    */
   @After("selectGetAge()")
   public void afterAdvice(){
      System.out.println("Student profile setup completed.");
   }  
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Name : Zara
Age : 11
Student profile setup completed.

@AfterReturningé um tipo de conselho, que garante que um conselho seja executado depois que o método for executado com êxito. A seguir está a sintaxe do conselho @AfterReturning.

Sintaxe

@AfterReturning(PointCut = "execution(* com.tutorialspoint.Student.*(..))", 
   returning = "retVal")
public void afterReturningAdvice(JoinPoint jp, Object retVal){
   System.out.println("Method Signature: "  + jp.getSignature());  
   System.out.println("Returning:" + retVal.toString() );
}

Onde,

@AfterReturning - Marque uma função como um conselho a ser executado antes do (s) método (s) coberto (s) por PointCut, se o método retornar com sucesso.
PointCut - Fornece uma expressão para selecionar uma função
execution( expression ) - Expressão cobrindo métodos nos quais o conselho deve ser aplicado.
returning - Nome da variável a ser retornada.

Para entender os conceitos mencionados acima relacionados ao @AfterReturning Advice, vamos escrever um exemplo, que implementará @AfterReturning Advice. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.JoinPoint;  
import org.aspectj.lang.annotation.AfterReturning; 

@Aspect
public class Logging {

   /** 
    * This is the method which I would like to execute
    * after a selected method execution.
    */
   @AfterReturning(PointCut = "execution(* com.tutorialspoint.Student.*(..))", 
      returning = "retVal")
   public void afterReturningAdvice(JoinPoint jp, Object retVal){
      System.out.println("Method Signature: "  + jp.getSignature());  
      System.out.println("Returning:" + retVal.toString() );
   }
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Age : 11
Method Signature: Integer com.tutorialspoint.Student.getAge()  
Returning 11

@AfterThrowingé um tipo de conselho que garante que um conselho seja executado se o método lançar uma exceção. A seguir está a sintaxe do conselho @AfterThrowing.

Sintaxe

@AfterThrowing(PointCut = "execution(* com.tutorialspoint.Student.*(..))", 
   throwing = "error")
public void afterThrowingAdvice(JoinPoint jp, Throwable error){
   System.out.println("Method Signature: "  + jp.getSignature());  
   System.out.println("Exception: "+error);  
}

Onde,

@AfterThrowing - Marque uma função como um conselho a ser executado antes do (s) método (s) coberto (s) por PointCut, se o método lançar uma exceção.
PointCut - Fornece uma expressão para selecionar uma função.
execution( expression ) - Expressão cobrindo métodos nos quais o conselho deve ser aplicado.
throwing - Nome da exceção a ser retornada.

Para entender os conceitos mencionados acima relacionados a @AfterThrowing Advice, vamos escrever um exemplo que implementará @AfterThrowing Advice. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.JoinPoint;  
import org.aspectj.lang.annotation.AfterThrowing;  

@Aspect
public class Logging {

   /** 
    * This is the method which I would like to execute
    * after a selected method execution throws exception.
    */
   @AfterThrowing(PointCut = "execution(* com.tutorialspoint.Student.*(..))", 
      throwing = "error")
   public void afterThrowingAdvice(JoinPoint jp, Throwable error){
      System.out.println("Method Signature: "  + jp.getSignature());  
      System.out.println("Exception: "+error);  
   }
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.printThrowException();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Exception raised
Method Signature: void com.tutorialspoint.Student.printThrowException()
Exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException
   
   at com.tutorialspoint.Student.printThrowException(Student.java:25)
   
   at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>)
   
   at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
   
   at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
   
   at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$99b0a988.printThrowException(<generated>)
   
   at com.tutorialspoint.MainApp.main(MainApp.java:13)

@Aroundé um tipo de conselho, que garante que um conselho possa ser executado antes e depois da execução do método. A seguir está a sintaxe do conselho @Around.

Sintaxe

@PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetName(){}

@Around("selectGetAge()")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
   System.out.println("Around advice");
   Object[] args = jp.getArgs();
   if(args.length>0){
      System.out.print("Arguments passed: " );
      for (int i = 0; i < args.length; i++) {
         System.out.print("arg "+(i+1)+": "+args[i]);
      }
   }

   Object result = jp.proceed(args);
   System.out.println("Returning " + result);
   return result.toString();   
}

Onde,

@PointCut - Marque uma função como PointCut
execution( expression ) - Expressão cobrindo métodos nos quais o conselho deve ser aplicado.
@Around - Marque uma função como um conselho a ser executado antes dos métodos cobertos pelo PointCut.

Para entender os conceitos mencionados acima relacionados ao @Around Advice, vamos escrever um exemplo que implementará o @Around Advice. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring -

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint; 

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
   private void selectGetAge(){}

   /** 
    * This is the method which I would like to execute
    * around a selected method execution.
    */
   @Around("selectGetAge()")
   public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
      System.out.println("Around advice");
      Object[] args = proceedingJoinPoint.getArgs();
      if(args.length>0){
         System.out.print("Arguments passed: " );
         for (int i = 0; i < args.length; i++) {
            System.out.print("arg "+(i+1)+": "+args[i]);
         }
      }

      Object result = proceedingJoinPoint.proceed(args);
      System.out.println("Returning " + result);
   }  
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Around advice
Age : 11
Returning 11

Até agora, declaramos aspectos usando <aop:config> ou < aop:aspectj-autoproxy>. Podemos criar um proxy programaticamente, bem como invocar os aspectos programaticamente usando o objeto proxy.

Sintaxe

//Create object to be proxied
Student student = new Student();

//Create the Proxy Factory
AspectJProxyFactory proxyFactory = new AspectJProxyFactory(student);

//Add Aspect class to the factory
proxyFactory.addAspect(Logging.class);

//Get the proxy object
Student proxyStudent = proxyFactory.getProxy();

//Invoke the proxied method.
proxyStudent.getAge();

Onde,

AspectJProxyFactory - Classe de fábrica para criar um objeto proxy.
Logging.class - Aula do Aspecto contendo conselhos.
Student - Classe executiva a aconselhar.

Para entender os conceitos mencionados acima relacionados ao proxy, vamos escrever um exemplo que implementará o proxy. Para escrever nosso exemplo com alguns conselhos, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring -

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Before;

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
   private void selectGetAge(){}

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   @Before("selectGetAge()")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }  
}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
  
   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }   
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      //Create the Proxy Factory
      AspectJProxyFactory proxyFactory = new AspectJProxyFactory(student);

      //Add Aspect class to the factory
      proxyFactory.addAspect(Logging.class);

      //Get the proxy object
      Student proxyStudent = proxyFactory.getProxy();

      //Invoke the proxied method.
      proxyStudent.getAge();
 
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Going to setup student profile.
Age : 11

De acordo com as expressões PointCut, pode ser o caso de serem aplicadas a alguns outros beans para os quais o conselho não se destina. Por exemplo, considere a seguinte expressão.

execution(* com.tutorialspoint.*.getAge(..))

Um novo bean de primavera é adicionado com o método getAge () e o conselho começará a ser aplicado a ele, embora possa não ser o pretendido. Para conseguir isso, podemos criar uma anotação personalizada e anotar os métodos nos quais o conselho deve ser aplicado.

@Before("@annotation(com.tutorialspoint.Loggable)")

Degrau	Descrição
1	Atualize o projeto que o Aluno criou no capítulo Spring AOP - Aplicativo .
2	Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo.

A seguir está o conteúdo de Logging.javaArquivo. Este é, na verdade, um exemplo do módulo de aspecto, que define os métodos a serem chamados em vários pontos.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class Logging {

   /** 
    * This is the method which I would like to execute
    * before a selected method execution.
    */
   @Before("@annotation(com.tutorialspoint.Loggable)")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }  
}

A seguir está o conteúdo do Loggable.java arquivo -

package com.tutorialspoint;

public @interface Loggable {

}

A seguir está o conteúdo do Student.java Arquivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }
   
   public void setName(String name) {
      this.name = name;
   }
   
   @Loggable
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

A seguir está o conteúdo do MainApp.java Arquivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");

      Student student = (Student) context.getBean("student");

      student.getName();
      student.getAge();     
   }
}

A seguir está o arquivo de configuração Beans.xml.

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name"  value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Executar projeto

Going to setup student profile.
Name : Zara
Age : 11

Spring AOP - Guia rápido

Requisitos de sistema

Etapa 1: verifique a instalação do Java

Etapa 2: definir seu ambiente Java

Etapa 3: Baixe o arquivo Maven

Etapa 4: Extraia o arquivo Maven

Etapa 5: definir as variáveis ​​de ambiente Maven

Etapa 6: adicionar localização do diretório Bin Maven ao caminho do sistema

Etapa 7: verificar a instalação do Maven

Etapa 8 - Configurar IDE Eclipse

Com base em esquema XML

Declarando um Aspecto

Declarando um PointCut

Declarando Conselhos

Baseado em @AspectJ

Declarando um Aspecto

Declarando um PointCut

Declarando Conselhos

Crie um Projeto

Importar projeto no Eclipse

Executar projeto

Ponto de junção

PointCut

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Executar projeto

JoinPoint

PointCut

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Sintaxe

Executar projeto

Executar projeto

Etapa 5: definir as variáveis de ambiente Maven