Olá Pessoal,
No post de hoje vamos ver como usar annotations para AOP é bem simples.Já vimos aqui com XML e agora vamos para o que há de melhor desde do Java 5 que é o uso de Annotations.
Lets go…
Starting
O post é bem curto e procurei ser bem objetivo, então considerando que você já tem seu arquivo de spring configurado para usar aop, vamos apenas atualizar para habilitar o recurso de annotations e aproveitei removi os beans usando auto-discovering do Spring. Vamos começar pela configuração do arquivo springconfiguration.xml (o nome que dei ao meu arquivo de configuração).
Antes disso, crie um projeto novo e dê o nome que quiser.
Note: lembre-se de adicionar os .jars do Spring, AOP e AspectJ ao projeto:
Configurando .xml do Spring
<beans xmlns=“http://www.springframework.org/schema/beans”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
xmlns:context=“http://www.springframework.org/schema/context”
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.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd”>
<context:component-scan base-package=“*”/>
<aop:aspectj-autoproxy/>
</beans>
Deixei seu arquivo de configuração assim. A única coisa nova de aop, foi que adicionar a linha <aop:aspectj-autorproxy/> que nos permite usar annotations.
Criando o bean
A seguir vamos criar o bean , nada demais neles:
@Component
@Scope(value=”prototype”)
public class Student {
private String name;
// this is DI via annotations
@Autowired
private Course course;
public String getName() {
return name;
}
public void setName(String name) {
if (name==null) {
throw new IllegalArgumentException();
}
this.name = name;
}
public Course getCourse() {
return course;
}
public void setCourse(Course course) {
this.course = course;
}
public void teste(){
}
}
O outro bean:
@Component
public class Course {
private String nameCourse;
public String getNameCourse() {
return nameCourse;
}
public void setNameCourse(String nameCourse) {
this.nameCourse = nameCourse;
}
}
Agora vamos criar uma classe que será responsável por registrar uma mensagem antes;após de determinados métodos, ou seja, as regras do AOP estarão aqui:
@Aspect
@Component
public class Audit {
// aqui com o metodo especifico
@Pointcut(“execution(* br.com.camilolopes.bean.Student.setName(..))”)
public void aopteste(){}
@Pointcut(“execution(* br.com.camilolopes.bean.Course.setNameCourse(..))”)
public void aopcourse(){}
@Pointcut(“execution(* *.*test*(..))”)
public void aopanywhere(){}
@AfterReturning(“aopteste()”)
public void register(){
System.out.println(“Student registred”);
}
@After(“aopcourse()”)
public void finished(){
System.out.println(“Course finished”);
}
@AfterThrowing(“aopteste()”)
public void problem(){
System.out.println(“Happened problem here”);
}
@Before(“aopteste()”)
public void starting(){
System.out.println(“application is starting…”);
}
@AfterReturning(“aopanywhere()”)
public void anywhere(){
System.out.println(“anywhere test”);
}
}
Observe que anotei a classe com @Component para que o Spring saiba que precisa registrar ela no contexto. Caso contrário, nada rola. Agora vamos entender os pointcuts criados:
- Primeiro: criamos um pointcut que sempre será chamado quando um método especifico for chamado nesse caso o método setName da classe Student.
- Segundo: o mesmo que acima, exceto que para a classe Course.
- Terceiro : agora criamos um que estou dizendo: “de qualquer lugar da aplicação e qualquer método que comece com test e terminar com qualquer coisa.
E os métodos a seguir é o que serão chamados com base no que tipo de anotação que definimos, observe que temos um que será chamado apenas no caso de acontecer uma exceção quando no método setName da classe Student.
Testando
Para testar aplicação criei uma classe de teste
Classe de Test
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={“classpath:config/springconfiguration.xml”})
public class StudentTest {
@Autowired
private Student student;
@Before
public void setUp() throws Exception {
}
@Test
public void testNameCourse() {
student.getCourse().setNameCourse(“TDD”);
assertEquals(“TDD”,student.getCourse().getNameCourse());
}
@Test
public void testNameStudent(){
student.setName(“Camilo”);
assertEquals(“Camilo”, student.getName());
student.teste();
}
@Test(expected=IllegalArgumentException.class)
public void testNameIsNullException(){
student.setName(null);
}
}
Resultado:
Classe com o método main
Fiz uma pequena classe com método main, para quem não sabe unit test:
public class MainTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“config/springconfiguration.xml”);
Student bean = (Student) applicationContext.getBean(“student”);
bean.setName(“lopes”);
bean.teste();
}
}
O resultado será diferente pq as inovações são diferentes:
Bom, pessoal. Vou ficando por aqui e espero que tenham gostado do post.
Abraços,