febrero 22, 2016 Reynaldo Claros
Asi como las clases y palabras reservadas en java, existe un tipo especial para definir como anotación, es allí donde uno puede crear sus propias anotaciones para usos específicos.
Las anotaciones es una especificación en cual busca simplificar el código usado en java, así mismo junto con Java Reflexion, nos brinda la potencia de poder tener control total de las anotaciones que implementemos.
Las anotaciones son amplia mente utilizadas por la mayorías de frameworks java, por ejemplo Spring Framework con sus @Autowired, Hibernate también hace uso de las anotaciones para simplificar el mapeo de los objetos, evitando escribir en archivos xml.
Vamos a crear nuestra propia anotación y vamos a ver también como podemos usarlo, un caso tipico seria en una validación.
No necesitamos dependencias ya que es una implementan nativa de java.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
*
* @author Reynaldo Claros
* @email reyiclaros@gmail.com
*/
@Documented
@Target(ElementType.FIELD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnotacion {
String mensahe() default "";
}
|
Esta anotación lo que va hacer es capturar el valor que tiene asignado el campo de la clase que definiremos.
La clase
MyClase lo definimos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| /**
*
* @author Reynaldo Claros
* @email reyiclaros@gmail.com
*/
public class MyClase {
@MyAnotacion(mensahe = "Campo name")
private String name;
@MyAnotacion(mensahe = "Campo dni")
private String dni;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDni() {
return dni;
}
public void setDni(String dni) {
this.dni = dni;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
|
Después solo tenemos que instanciar la clase asignarle los parámetros y enviarlo a un método para su procesamiento.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| public static void main(String[] args) {
MyClase clase = new MyClase();
clase.setName("Java for Developers");
clase.setDni("19283282222");
clase.setAge(2);
/**
* Procesamos
*/
procesandoAnotacion(clase);
}
private static void procesandoAnotacion(Object obj) {
Class cl = obj.getClass();
try {
for (Field field : cl.getDeclaredFields()) {
field.setAccessible(true);
try {
for (Annotation anno : field.getDeclaredAnnotations()) {
if (anno.annotationType() == MyAnotacion.class) {
MyAnotacion myanotacion = (MyAnotacion) anno;
System.out.println("Mensaje de la anotacion : " + myanotacion.mensahe());
System.out.println("Nombre del campo : " + field.getName());
System.out.println("Valor del campo : " + field.get(obj).toString());
System.out.println("----------------------------");
}
}
} catch (IllegalAccessException | IllegalArgumentException | SecurityException e) {
System.out.println(e.getMessage());
}
}
} catch (SecurityException | IllegalArgumentException e) {
System.out.println(e.getMessage());
}
}
|
El resultado es:
1
2
3
4
5
6
7
8
| Mensaje de la anotacion : Campo name
Nombre del campo : name
Valor del campo : Java for Developers
----------------------------
Mensaje de la anotacion : Campo dni
Nombre del campo : dni
Valor del campo : 19283282222
----------------------------
|
Como podéis ver, las anotaciones son una poderosa herramienta, cuando queremos hacer nuestros propios validadores y otros cometidos.
Saludos cordiales.
0 comments:
Publicar un comentario