tag:blogger.com,1999:blog-10157713974985664332024-03-17T23:03:54.504-07:00harto codigoVictor Hugohttp://www.blogger.com/profile/05304356821263951886noreply@blogger.comBlogger5125tag:blogger.com,1999:blog-1015771397498566433.post-45690015014712123312011-08-10T04:24:00.000-07:002011-08-10T10:51:29.454-07:00Plantilla para web.xml (Servlet spec 2.5)<p>Solo porque es un recurso que es muy utilizado y continuamente lo tengo que buscar, aquí les pongo una plantilla vacía para un archivo <i>web.xml</i> de la especificación Java Servlets 2.5</p>
<div class="codigo"><pre><?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app></pre></div>Victor Hugohttp://www.blogger.com/profile/05304356821263951886noreply@blogger.com0tag:blogger.com,1999:blog-1015771397498566433.post-34792181546884852252011-02-15T05:14:00.000-08:002011-02-15T07:53:01.684-08:00Comandos básicos de MySQL para crear un usuario y darle permisos<p>Listaré rapidamente los comandos básicos para crear una base de datos,
un usuario y asignarle permisos a ese usuario para acceder a dicha base de datos.</p>
<p>Cuando comenzamos con algun proyecto que requiera base de datos es importante:</p>
<ul>
<li>Tener un usuario destinado unicamente a la aplicación para que la base de datos no
sea accedida por <em>cualquiera</em>.</li>
<li>Que el usuario creado este restringido por host de origen para aumentar la seguridad</li>
</ul>
<p>Los siguientes comandos son muy <em>autodescriptivos</em> asi que no incurriré en ninguna explicación. Simplemente busco que esta entrada sea una referencia rápida al comenzar a programar algo.</p>
<div class="consola"><pre>
mysql> <span class="x">CREATE DATABASE</span> projectdb;
mysql> <span class="x">CREATE USER</span> 'projectuser'@'localhost' <span class="x">IDENTIFIED BY</span> 'password';
mysql> <span class="x">GRANT ALL PRIVILEGES ON</span> projectdb.* <span class="x">TO</span> 'projectuser'@'localhost' <span class="x">WITH GRANT OPTION</span>;
</pre></div>
<p>La documentación de estos comandos se encuentra en el <a href="http://dev.mysql.com/doc/refman/5.1/en/adding-users.html" target="_blank">sitio de MySQL</a>.</p>Victor Hugohttp://www.blogger.com/profile/05304356821263951886noreply@blogger.com0tag:blogger.com,1999:blog-1015771397498566433.post-88179320185538695032009-05-19T20:40:00.000-07:002011-08-14T11:18:46.011-07:00Instalar LJMT (Linux, Java, Maven, Tomcat)<p>En este <em>post</em> explicaré la forma mas rápida de instalar
un entorno de desarrollo de aplicaciones J2EE <strong>muy básico</strong>
usando Linux, Java, Maven y Tomcat.</p>
<p><strong>Linux - Ubuntu</strong></p>
<p>Escogí Ubuntu por las siguientes razones:</p>
<ul>
<li>Es una distribución estable basada en Debian</li>
<li>Su <a href="https://help.ubuntu.com/" target="_blank">documentación</a> es excelente.</li>
<li>Tiene buen soporte en su <a href="http://ubuntuforums.org/" target="_blank">foro</a>.</li>
<li>Su herramienta <a href="http://en.wikipedia.org/wiki/Advanced_Packaging_Tool" target="_blank">apt</a>.
<li>Tiene buen soporte del hardware en las computadoras donde lo he instalado.</li>
<li>Si es que se utiliza como Desktop, los <a href="http://www.youtube.com/watch?v=ZxfSwzhSn1c" target="_blank">efectos del Compiz</a> son muy buenos.</li>
</ul>
<p>No ahondaré en detalles sobre la instalación de Ubuntu
porque además de que es muy sencilla, hay muchos tutoriales por
ahí que tratan este tema.
Todos los pasos del resto de la guía serán realizados en la consola,
así que pueden instalar la versión
<a href="http://www.ubuntu.com/products/WhatIsUbuntu/desktopedition" target="_blank">Desktop</a>
, <a href="http://www.ubuntu.com/products/whatisubuntu/serveredition" target="_blank">Server</a>
o incluso una versión instalada en una máquina virtual sobre su amado Windows, da igual.</p>
<div class="referencia">
<table><tr><td valign="top">
<img src="http://www.ubuntu.com/themes/ubuntu07/images/icon-ubuntu.png"
style="border: 0; margin-right: 10px; margin-top: 0px;" align="left" />
</td><td valign="top">
<p><span class="x">Links Ubuntu</span><br />
Descargar -
<a class="x" href="http://www.ubuntu.com/getubuntu/download" target="_blank">http://www.ubuntu.com/getubuntu/download</a><br />
<strike>Solicitar el envío de un CD gratis -
<span class="x"><u>https://shipit.ubuntu.com/</u></span></strike><br />
Foro -
<a class="x" href="http://ubuntuforums.org/" target="_blank">http://ubuntuforums.org/</a><br />
Documentación -
<a class="x" href="https://help.ubuntu.com/" target="_blank">https://help.ubuntu.com/</a><br />
</p>
</td></tr></table>
</div>
<p>El unico detalle a considerar antes de trabajar con la instalación de Ubuntu es que, en caso de haber instalado la
versión <em>Server</em> será necesario asegurarnos que el servidor SSH se haya instalado; esto para poder
acceder al servidor remotamente. En caso de no haber sido instalado desde el <em>wizard</em> se puede instalar con la
siguiente instrucción:<p/>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">sudo apt-get</span> install sshd
</pre></div>
<p><strong>Java - Sun JDK6</strong></p>
<p>Aunque es posible instalar Java usando <span class="x">apt</span> yo recomiendo hacerlo manualmente ya que se tiene más
control sobre la instalación además de que es probable que
alguna vez tengamos que instalar varios JDKs o JREs y de este modo es mas fácil <em>switchear</em>
de una versión a otra.</p>
<p>Es necesario descargar una copia del JDK del sitio de <a href="http://java.sun.com/" target="_blank">Sun Microsystems</a>.
El archivo que utilizo como ejemplo en aqui es un binario (terminación .bin)</p>
<p>Si se utiliza una versión de Linux sin interfase gráfica se puede copiar al servidor usando SCP o algo similar.
En caso de no tener un cliente SCP disponible (gFTP es mi recomendación) se puede copiar un archivo al servidor
usando la siguiente instrucción de la línea de comandos:</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">scp</span> /ruta/del/archivo usuario@servidor:/carpeta/destino
</pre></div>
<p>Para descomprimir, solamente hay que asegurarse que se tengan permisos de ejecución en el archivo
y ejectutar el bin. Esto solamente creará una carpeta con los archivos necesarios en el mismo folder.</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">chmod</span> 755 jdk-6u11-linux-x64.bin
user@linuxbox:~$ <span class="x">./jdk-6u11-linux-x64.bin</span>
Sun Microsystems, Inc. Binary Code License Agreement
[puedes saltarte la licencia apretando 'q']
Do you agree to the above license terms? [yes or no]
yes
Unpacking...
Checksumming...
.
.
.
Done.
user@linuxbox:~$
</pre></div>
<p>Yo generalmente creo un folder <em>/usr/java</em> en donde guardo todos los archivos relacionados con Java
(como diferentes JDKs, JREs, Application Servers, Maven, Ant, etc.).</p>
<p>Escribir el folder <em>/usr</em>
requiere ser un super usuario asi que tenemos que usar <span class="x">sudo</span>
para crear el directorio. Después de esto lo único que hay que hacer
es mover el folder con los archivos del JDK a esta nueva ubicación.</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">sudo mkdir</span> /usr/java
[sudo] password for linuxbox: [el password con que el que ingresaste]
user@linuxbox:~$ <span class="x">sudo mv</span> jdk1.6.0_11 /usr/java
</pre></div>
<p>Finalmente es necesario agregar la variable JAVA_HOME en el archivo .profile en el home
del usuario actual y agregar su carpeta <em>bin</em> al PATH</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">vi</span> ~/.profile
</pre></div>
<div class="codigo"><pre>
.
.
.
<span class="x">JAVA_HOME</span>=/usr/java/jdk1.6.0_11
export JAVA_HOME
<span class="x">PATH</span>=$PATH:$JAVA_HOME/bin
export PATH
</pre></div>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">source</span> ~/.profile
</pre></div>
<p>Para probar la instalación solamente hay que introducir:</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">java</span> -version
java version "1.6.0_11"
Java(TM) SE Runtime Environment (build 1.6.0_11-b03)
Java HotSpot(TM) Client VM (build 11.0-b16, mixed mode, sharing)
</pre></div>
<p><strong>Maven 2</strong></p>
<p>Maven es un robusto gestor de dependencias distribuido con varios <em>plugins</em> (incluso el compilador
es un <em>plugin</em>) que facilitan la tarea de gestionar, construir y hacer el <em>deploy</em> de proyectos J2EE.
Maven basa las reglas para construir un proyecto
en un archivo XML llamado POM (Project Object Model) el cual contiene los distintos <em>plugins</em> y su
configuración a utilizar durante el ciclo de vida de la construcción de un proyecto.
Muchas personas lo encuentran dificil de utilizar ya que se debe de tener una estructura específica
en los archivos fuente; a pesar de que esto tiene algunos contras tiene la gran ventaja
de que la estandarización tiene como consecuencia la agilización del mantenimiento
del proyecto.</p>
<p>Proximamente escribiré una entrada sobre el uso de Maven, mientras tanto me remitiré
a la instalación.</p>
<p>Al igual que Java, es posible instalar Maven utilizando el gestor de paquetes <span class="x">apt</span>,
sin embargo, prefiero el método manual ya que asi tenemos mas control sobre la instalación
(además de que en este caso es aún más sencillo).</p>
<p>Para descargar Maven basta con dirigirnos a <a href="http://maven.apache.org/download.html">maven.apache.org</a> y escoger algún <em>mirror</em>,
el tipo de archivo que uso en este tutorial es un <em>tar.gz</em>. Después de obtener el archivo, es necesario descomprimirlo.
Con esto obtendremos una carpeta llamada <em>apache-maven-2.0.10</em>, ahora solamente tenemos que copiar el folder a
<em>/usr/java</em> (siguiendo la recomendación de poner todos los archivos de Java en un solo lugar).</p>
<p>Aqui presento los comandos para descargar, descomprimir y colocar la version de Maven 2.0.10</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">wget</span> http://archive.apache.org/dist/maven/binaries/apache-maven-2.0.10-bin.tar.gz
user@linuxbox:~$ <span class="x">tar</span> -xvfz apache-maven-2.0.10-bin.tar.gz
user@linuxbox:~$ <span class="x">sudo cp</span> apache-maven-2.0.10 /usr/java
</pre></div>
<p>Finalmente debemos editar nuestro archivo .profile para 'dar de alta' la variable de entorno M2_HOME apuntando al home de Maven
(esta es opcional pero hace más claro el script) y agregar al PATH la ubicación $M2_HOME/bin.</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">vi</span> ~/.profile
</pre></div>
<div class="codigo"><pre>
.
.
.
<span class="x">M2_HOME</span>=/usr/java/apache-maven-2.0.10
export M2_HOME
<span class="x">PATH</span>=$PATH:$M2_HOME/bin
export PATH
</pre></div>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">source</span> ~/.profile
</pre></div>
<p>Para probar la instalación únicamente usamos <span class="x">mvn</span> con el parámetro -version</p>
<div class="consola"><pre>
user@linuxbox:~$ mvn -version
Maven version: 2.0.9
Java version: 1.6.0_11
OS name: "linux" version: "2.6.27-14-generic" arch: "i386" Family: "unix"
</pre></div>
<p><strong>Intermedio</strong></p>
<p>Hasta ahora debemos de tener una estación de trabajo preparada para poder programar y compilar proyectos Java,
necesitamos únicamente un <em>application server</em> para poder hacer <em>deploy</em> de una aplicación Web.
Con las herramientas que tenemos hasta ahorita podemos hacer el experimento de un 'Hello World' (en Web)
usando solamente Maven y su plugin <em>archetype</em>.</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">mvn</span> archetype:create \
-DgroupId=com.hartoingenio \
-DartifactId=web-artifact \
-DarchetypeArtifactId=maven-archetype-webapp
.
.
.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 33 seconds
[INFO] Finished at: Tue May 19 16:41:13 PDT 2009
[INFO] Final Memory: 8M/14M
[INFO] ------------------------------------------------------------------------
user@linuxbox:~$ <span class="x">cd</span> web-artifact/
user@linuxbox:~$ <span class="x">mvn</span> clean war:exploded tomcat:run
.
.
.
May 19, 2009 4:41:17 PM org.apache.coyote.http11.Http11Protocol start
INFO: Starting Coyote HTTP/1.1 on http-8080
</pre></div>
<p>Sólo pon en tu navegador el siguiente URL (en caso de que el proyecto no haya sido creado en el mismo equipo,
reemplaza <em>localhost</em> por el nombre o dirección IP del servidor).</p>
<div class="referencia"><pre>
http://localhost:8080/web-artifact/
</pre></div>
<p>Esto que acabamos de hacer no instala Tomcat en el equipo, simplemente Maven descarga los JARs de Tomcat del repositorio y echa a andar una versión <em>slim</em>.</p>
<p><strong>Apache Tomcat 6.0.18</strong></p>
<p>La instalación de Tomcat muy sencilla, muy parecido a lo que hicimos con Maven. Para descargar Tomcat basta con dirigirnos a <a href="http://tomcat.apache.org/download-60.cgi">tomcat.apache.org</a> y escoger algún <em>mirror</em>,
el tipo de archivo que uso en este tutorial es un <em>tar.gz</em>. Después de obtener el archivo, es necesario descomprimirlo.
Con esto obtendremos una carpeta llamada <em>apache-tomcat-6.0.18</em>, ahora solamente tenemos que copiar el folder a
<em>/usr/java</em> (siguiendo la recomendación de poner todos los archivos de Java en un solo lugar).</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">wget</span> http://archive.apache.org/dist/tomcat/tomcat-6/v6.0.18/bin/apache-tomcat-6.0.18.tar.gz
user@linuxbox:~$ <span class="x">tar</span> -xvfz apache-tomcat-6.0.18.tar.gz
user@linuxbox:~$ <span class="x">sudo cp</span> apache-tomcat-6.0.18 /usr/java
</pre></div>
<p>Finalmente debemos editar nuestro archivo .profile para 'dar de alta' la variable de entorno CATALINA_HOME apuntando al home de la instalación de Tomcat y agregar al PATH la ubicación <em>$CATALINA_HOME/bin.</em></p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">vi</span> ~/.profile
</pre></div>
<div class="codigo"><pre>
.
.
.
<span class="x">CATALINA_HOME</span>=/usr/java/apache-tomcat-6.0.18
export CATALINA_HOME
<span class="x">PATH</span>=$PATH:$CATALINA_HOME/bin
export PATH
</pre></div>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">source</span> ~/.profile
</pre></div>
<p>Para probar la instalación simplemente introducimos:</p>
<div class="consola"><pre>
user@linuxbox:~$ <span class="x">catalina.sh</span> run
.
.
.
INFO: Server startup in 961 ms
user@linuxbox:~$
</pre></div>
<p>Y checamos en:</p>
<div class="referencia"><pre>
http://localhost:8080/
</pre></div>
<p>Listo!</p>Victor Hugohttp://www.blogger.com/profile/05304356821263951886noreply@blogger.com0tag:blogger.com,1999:blog-1015771397498566433.post-9372190611025974332009-05-11T12:08:00.000-07:002009-05-12T20:14:53.284-07:00Comandos más utilizados en Linux<p>Encontré este comando ingenioso que muestra los comandos más utilizados en la consola y el número de veces que los hemos ejecutado:</p>
<div class="codigo"><pre>
<span class="x">history</span> | <span class="x">awk</span> '{a[$2]++}END{for(i in a){print a[i] " " i}}' | <span class="x">sort</span> -rn | <span class="x">head</span> -n 10
</pre></div>
<p>Aquí la explicación del script:
<ul>
<li><strong>history</strong> - Obtiene la lista de comandos usados recientemente con el siguiente formato:<br />
<blockquote>100 cd project<br />
101 mvn clean install<br />
102 cd target<br />
103 cp project-1.0.jar /somewhere</blockquote>
(no estoy seguro con que vigencia se 'guardan' los comandos; si lo encuentro actualizo).</li>
<li><strong>awk '{a[$2]++}END{for(i in a){print a[i] " " i}}'</strong> -
Utiliza <a href="http://www.gnu.org/software/gawk/" target="_blank">awk</a> para incrementar los valores de un arreglo <em>a</em>,
usando el comando introducido como llave (el segundo parámetro de la lista anterior).<br />
Después de haber recibido la lista, simplemente recorre el arreglo y lo imprime en pantalla.</li>
<li><strong>sort -rn</strong> - Ordena la lista generada por el comando anterior de mayor a menor y usando la representación numérica de la cadena</li>
<li><strong>head -n 10</strong> - Muestra solo los primeros 10 elementos de la lista (si usamos solo <em>head</em> sin parametros muestra 10,
agregué el -n 10 para hacerlo más claro).</li>
</ul>
</p>
<p>Mi resultado fue:</p>
<div class="consola"><pre>
vhuerta@vhuertat43:~$ <span class="x">history</span> | <span class="x">awk</span> '{a[$2]++}END{for(i in a){print a[i] " " i}}' | <span class="x">sort</span> -rn | <span class="x">head</span> -n 10
111 svn
88 cd
83 ls
34 mvn
23 exit
19 man
16 ssh
15 cat
12 sudo
12 ps
</pre></div>
<p>Hmmm... Interesante</p>Victor Hugohttp://www.blogger.com/profile/05304356821263951886noreply@blogger.com0tag:blogger.com,1999:blog-1015771397498566433.post-63571540651423034302009-02-17T19:42:00.000-08:002011-02-15T05:43:30.897-08:00Anotaciones en Java 5+<p>Cuando salió Java 5 el código se lleno de anotaciones. Para los que no las ubiquen
son esas sentencias que comienzan con una @ y que se colocan antes de la declaración
de una clase o de un atributo o de un método:</p>
<div class="codigo"><pre>
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
<span class="x">@Deprecated</span>
public class AlgunaClaseTest {
<span class="x">@Before</span>
public void setUp() {
}
<span class="x">@Test</span>
public void testAlgo() {
}
<span class="x">@After</span>
public void tearDown() {
}
}
</pre></div>
<p>Al principio me disgustaban ya que a mi gusto ensuciaban el código y rompian con las
reglas de sintaxis basicas de Java (the simpler the better), pero pasado de un tiempo
es posible por fin tenerles agrado después de ver todas sus ventajas.</p>
<p>Una anotación se define asi en el código:</p>
<div class="codigo"><pre>
public <span class="x">@interface</span> Anotacion {
}
</pre></div>
<p>O asi en caso de que quisieramos parametros:</p>
<div class="codigo"><pre>
public <span class="x">@interface</span> AnotacionParametro {
String parametro();
}
</pre></div>
<div class="codigo"><pre>
public <span class="x">@interface</span> AnotacionParametros {
int id();
String valor();
}
</pre></div>
<p>Las anotaciones pasadas se podrian usar de este modo en una clase</p>
<div class="codigo"><pre>
<span class="x">@Anotacion</span>
public class AlgunaClase {
<span class="x">// Cuando es un solo parametro se puede omitir el nombre y el '='</span>
<span class="x">@AnotacionParametro("parametro")</span>
public void algunMetodo() {
}
<span class="x">@AnotacionParametros(id=1, valor="algo")</span>
public void algunOtroMetodo() {
}
}
</pre></div>
<p>Es importante al ver el código el no confundir a la a anotación con una
<em>interface</em> tradicional, las anotaciones no se heredan ni forman parte del
diseño de clases de los sistemas, estas unicamente sirven para agregarle
metadatos al miembro sobre el cual se colocan. Se podria decir que son 'comentarios avanzados'.</p>
<p>El ponerle anotaciones al código no cambiaria <span class="x">ABSOLUTAMENTE NADA</span>
en el comportamiento del mismo. La pregunta es entonces: Si no cambia nada,
¿Para qué las quiero?</p>
<p><strong>Ejemplo</strong></p>
<p>Supongamos que queremos crear un programa que permita correr clases tipo pruebas unitarias
y que queremos que solamente se ejecuten los métodos que esten definidos como pruebas:</p>
<div class="codigo"><pre>
public class TestCase {
<span class="x">@Test</span>
public void prueba() { }
<span class="x">@Test</span>
public void excepcion() {
throw new RuntimeException("Error aqui");
}
<span class="x">@Test</span>
public void otraPrueba() { }
<span class="x">@Test</span>
public void otraExcepcion() {
throw new RuntimeException("Otro error aqui");
}
}
</pre></div>
<p>Para esto previamente tendríamos que haber definido una anotación llamada <em>Test</em>,
la cual deberia de ser importada por todas las clases que se quisieran probar. Nuestra
anotación debe de tener definida otra anotación para que funcione del modo que queremos
(sí, las anotaciones pueden tener anotaciones :) ), esta es
<span class="x">@Retention</span> y tiene como atributo la política de retención
<span class="x">RetentionPolicy.RUNTIME</span> para que el compilador la mantenga
ahi después de haber creado el archivo <em>class</em>, ya que por default son eliminadas
al compilar el archivo. Otra anotación que es conveniente indicar es
<span class="x">@Target(ElementType.METHOD)</span> para evitar que sea colocada en
otro elemento que no sea un método. Estas anotaciones y enumeraciones estan todas
en el paquete <em>java.lang.annotation</em></p>
<div class="codigo"><pre>
import java.lang.annotation.*;
<span class="x">@Retention(RetentionPolicy.RUNTIME)</span>
<span class="x">@Target(ElementType.METHOD)</span>
public @interface Test {
}
</pre></div>
<p>Y ahora si, nuestro <em>Test Runner</em> quedaria del siguiente modo:</p>
<div class="codigo"><pre>
import java.lang.reflect.*;
public class TestRunner {
public static void main(String[] args) throws Exception {
int exito = 0;
int fallas = 0;
Class<?> clazz = Class.forName(args[0]);
Object obj = clazz.newInstance();
for (Method m : clazz.getMethods()) {
if (<span class="x">m.isAnnotationPresent(Test.class)</span>) {
try {
m.invoke(obj);
System.out.printf("Prueba %s ejecutado%n", m.getName());
exito++;
} catch (Throwable t) {
System.out.printf("Prueba %s fallo: %s %n", m, t.getCause());
fallas++;
}
}
}
System.out.printf("OK: %d, Fallas: %d%n", exito, fallas);
}
}
</pre></div>
<p>El código es muy sencillo, unicamente crea un objeto usando la clase pasada
como primer argumento en la línea de comandos y ejecuta todos los métodos que
tengan una anotación del tipo Test.class definida, hace un conteo de errores
y finalmente muestra el resumen.</p>
<p><strong>Conclusión</strong></p>
<p>Muchos de los frameworks actuales utilizan <em>reflection</em> muchísimo (Spring,
JUnit, Hibernate, JSF, etc, etc, etc...), la implementación de anotaciones desde
Java 5 ha permitido que algunos de estos se mantengan alejados del comportamiento
del código del sistema y unicamente utilicen los metadatos para llevar a cabo sus
tareas, favoreciendo asi la limpieza y legibilidad del código.</p>
<p>Es importante que aunque sea rara la vez que tengamos que programar una nueva
anotación, sepamos emplearlas correctamente y sacarles provecho para tener sistemas
mas limpios y menos acoplados.</p>
<p><strong>Links</strong></p>
<p>Aqui se puede encontrar la referencia oficial de Sun (in english of course) sobre
anotaciones, el ejemplo se tomo de aqui y fue mejorado en este post ;) -
<a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html" target="_blank">
http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html
</a></p>Victor Hugohttp://www.blogger.com/profile/05304356821263951886noreply@blogger.com8