Java y nuevas tecnologias

Ciclo de vida de JSF

2009-12-11T03:33:00.001-08:00

La primera fase puede denominarse como “Aplicar los valores de la petición” (ver recuadro 1). En ella se van recorriendo todos los componentes del formulario siguiendo la jerarquía padre-hijo al mismo tiempo que se recuperan sus valores a partir de los parámetros de la petición o request enviada al servidor. El valor se asigna a cada componente en su propiedad submittedValue.
Esto ocurre siempre excepto en dos casos: si el componente está deshabilitado (disabled = true) o si posee una condición que indica cuándo debe pintarse en pantalla(atributo ‘rendered’).
A continuación tendrá lugar bien la fase de validaciones o bien la ejecución de cada uno de sus eventos asociados dependiendo del valor del atributo ‘immediate’ de los componentes de la página (ver al final el apartado “Uso del atributo ‘immediate’.”).

Siguiendo la secuencia normal del ciclo, la siguiente fase que tiene lugar es la de “Procesamiento de las validaciones” (ver recuadro 2). Este proceso consiste en la validación del dato suministrado por el usuario en función de las reglas de validación definidas para el componente.
Es común el uso de un validator o un converter, que se aplica sobre el submittedValue. Si no se produce ningún error de validación o de conversión, el valor del submittedValue de cada componente válido pasa a ser null y entonces se almacena en su ‘value’ el dato convertido al tipo que tenga la propiedad del bean a la que se asignará posteriormente.
En caso contrario, el ciclo de vida avanza directamente hasta la fase de presentación de la respuesta.

Durante la fase de “Proceso de Eventos” (ver recuadro 3) se llevan a cabo todos los eventos asociados a las acciones realizadas por el usuario.

Pasamos a la próxima fase del ciclo: “Actualización de los valores del Modelo” (ver recuadro 4). Tras las validaciones y/o ejecución de los eventos tiene lugar la asignación del ‘value’ de los componentes a los atributos del bean.

Entonces llegamos a la fase conocida como “Invocar la aplicación” (ver recuadro 5) en la que se usan los valores del bean para ejecutar la lógica de negocio y se llevan a cabo las operaciones correspondientes a las acciones del usuario.

Por último, tiene lugar la fase: “Presentación de la respuesta” (ver recuadro 6). La implementación de JavaServer Faces delega su autoridad en el contenedor JSP para enseñar la página que el usuario ve por pantalla, y donde todos los campos están informados con su valor en ese momento.
Si se produjo un error en la fase de validación, se muestra la response (pantalla de respuesta) con los valores que introdujo el usuario y además un mensaje informativo del error. El valor que aparecerá en pantalla para cada componente de la página será el primero no nulo que el servidor encuentre en la secuencia:

Componente.submittedValue –> Componente.value –> Bean.attribute

Uso del atributo ‘immediate’

El atributo ‘immediate’ de los componentes de un formulario está presente en la mayoría de las fases del ciclo de vida.
Ya en la primera fase del ciclo se comprueba el valor de dicho atributo. Si vale true, el ciclo avanza hasta la tercera fase, saltándose las validaciones pertinentes. En caso contrario, se continúa el ciclo normal hacia la fase 2.
Es importante señalar en este punto que si ‘immediate’ no se indica su valor es false, ya que así está definido en la declaración de atributos de JSF. Y además es importante saber que el hecho de asignarle el valor true implica no tener acceso a los valores de los campos del formulario así como a los errores que se hubieran producido.

Glosario

Componente: elemento que forma parte del formulario y provee funcionalidades para interactuar con el usuario. Puede ser de diferentes tipos (caja de texto, botón, control de selección…) y el usuario “completa” el formulario a través de su modificación.

Converter: se utiliza cuando es necesario convertir el dato introducido por el usuario al tipo apropiado. Por ello hay que indicar como nombre el de una clase bean que implemente la interfaz Converter.

Evento: acción que queremos que se produzca al cambiar el valor del componente. Por ejemplo, el caso de un selectOneMenu cuando cambiamos la opción marcada del menú desplegable. Solemos indicar estas acción a través de los atributos ‘onchange’, ‘onblur’, ‘onclick’, etc. en el código jsp.

Evento de acción: acción declarada en el atributo ‘action’ de un componente. A cada botón que exista en una página le corresponde una acción (no necesariamente distinta a las demás), y que nosotros solemos denominar con los nombres “doXxxAction” o “goXxxAction”. Por ejemplo: doActualizarAction(), goAtrasAction().

Nota: JSF entiende ‘evento’ como cualquier acción realizada por el usuario. Por ejemplo: pulsar en un botón, hacer clic sobre un link, escribir en un inputText, etc. Como se lee un poco más arriba, nosotros distinguimos entre ‘eventos’ propiamente dichos, y ‘eventos de acción’.

SubmittedValue: valor introducido por el usuario en el formulario.

Validator: responsable de asegurar que el valor ingresado por un usuario es aceptable. Uno o más validadores pueden ser asociados con un solo componente y se definen en clases Java independientes.

rich:modalPanel

2009-12-01T04:27:00.001-08:00

Componente de RichFaces para que nos aparezca una ventana modal. Con esta ventana modal se pueden mostrar errores o el alta de una gestión, etc. A continuación expongo un ejemplo:

Se invocaria desde un componente mediante la sentencia oncomplete un ejemplo sería:

JPA (JAVA PERSISTENCE API)

2009-04-17T01:00:00.000-07:00

Hola gente , en la entrada de hoy voy hablar de JPA, para los que no sepan lo que es ,a grandes rasgos ,son unas APIS de java para tratar la base de datos como objetos mediante clases PERSISTENTES.

JPA te permite crear clases persistentes(Clase que sirven para almacenar datos , conviertiendose en tablas en la base de datos) .JPA utiliza anotaciones un ejemplo de clase persistente sería:

@Entity
public class Usuario {
@Id
private String id;
private String name;
private String email;
}

Con las anotaciones @Entity estamos diciendo que esa clase es persistente y como tal se creara una tabla en la base de datos ,@Id sirve para marcar la clave primaria y se coloca encima del atributo en este caso el atributo id de la clase Entity sera la clave primaria.

Es importante tener un archivo persistence.xml en la carpeta WEB-INF de tu proyecto que es donde estara la configuracion de tu JPA.

Bien una vez que tenemos el archivo de configuracion y las clases persistentes ¿como hacer que la clase persistente termine como tabla en la BD? basicamente con este Codigo:

- Primero creamos un EntityManager que nos permita manipular y trabajar con los objeto Entity:

String UNIDAD_DE_PERSISTENCIA = “DOCSPU”; EntityManagerFactory factory = Persistence.createEntityManagerFactory(UNIDAD_DE_PERSISTENCIA, System.getProperties()); em = factory.createEntityManager();

Como ves, el nombre que uso es “DOCSPU”, esto es porque asi lo tenemos definido en el fichero “persistence.xml”, asi sabe como recuperar las clases y propiedades que corresponden a esta unidad de persistencia. Si tu cambiaste el nombre en el XML, aqui deberias poner el que hayas usado.

Una vez creada la EntityManager, ya es muy simple, abrir una transaccion e incluso almacenar elementos (Entity) en la base de datos. Un ejemplo para insertar un “Usuario” podria ser:

em.getTransaction().begin(); Usuario u = new Usuario(); u.setId(100); u.setName(”jose”); u.setEmail(”notengo@gmail.com”); em.persist(u); em.flush(); em.getTransaction().commit();

Como observareis, hemos recuperado una transaccion (getTransaction), instanciado un objeto usuario, asignado valores a sus atributos, lo hemos “persistido” (almacenado) en la base de datos con “persist” y por ultimo un commit de la transaccion.Y aqui cierro la entrada de hoy , la proxima entrada hablar de como Consultar en JPA.

Instalacion JSF

2009-04-03T00:58:00.000-07:00

Requisitos:
S.O:WIN XP
JDK 1.5.0_6
TOMCAT 5.5.16
JavaServer Faces v 1.1

Descargamos el kit de desarrollo de Java de en lace:
http://java.sun.com/j2se/1.5.0/download.jsp

Se recomienda crear ArchivosDePrograma sin espacio. Una vez instalado vamos a las variables de entorno y modificamos la variable PATH agregandole la ruta donde esta el directorio bin de la instalacion de Java por ejemplo:

C:\ArchivosDePrograma\Java\jdk1.5.0_06\bin

Descargamos el servidor Tomcat del enlace:

http://tomcat.apache.org/download-55.cgi

Instalar la version completa para añadir Examples asi podremos disponer de las librerias standard.jar y jstl.jar , ubicadas en c:\ArchivosDePrograma\Tomcat5.5\webapps\jsp-examples\WEB-INF\lib, necesarias para cualquier aplicación JSF. En cuanto al directorio por comodidad:c:\ArchivosDePrograma\Tomcat5.5
El puerto sera por defecto 8080.

Es necesario agregar la variable JAVA_HOME para que apunte al directorio donde se haya instalado el JDK ( para que Tomcat sepa donde buscar el compilador de Java y demas utilidades) por ejemplo:
C:\ArchivosDePrograma\Java\jdk1.5.0_06

Establezca la variable CATALINA_HOME para que apunte al directorio donde instalo el Tomcat por ejemplo:
C:\ArchivoDePrograma\Tomcat5.5

Y volvemos a modificar la variable PATH para añadir el directorio bin de Tomcat ejemplo:

C:\ArchivoDePrograma\Tomcat5.5.

Swing

2008-06-05T00:08:00.001-07:00

Swing

Es muy importante entender y asimilar el hecho de que Swing es una extensión del AWT, y no un sustituto encaminado a reemplazarlo. Aunque esto sea verdad en algunos casos en que los componentes de Swing se corresponden a componentes del AWT; por ejemplo, el JButton de Swing puede considerarse como un sustituto del Button del AWT, y una vez que se usen los botones de Swing se puede tomar la decisión de no volver a utilizar jamás un botón de AWT, pero, la funcionalidad básica de Swing descansa sobre el AWT.

Swing proporciona un conjunto completo de Componentes, todos ellos lightweight, es decir, ya no se usan componentes "peer" dependientes del sistema operativo, y además, Swing está totalmente escrito en Java. Todo ello redunda en una mayor funcionalidad en manos del programador, y en la posibilidad de mejorar en gran medida la cosmética de los interfaces gráficos de usuario.

Son muchas las ventajas que ofrece el uso de Swing. Por ejemplo, la navegación con el teclado es automática, cualquier aplicación Swing se puede utilizar sin ratón, sin tener que escribir ni una línea de código adicional. Las etiquetas de información, o "tool tips", se pueden crear con una sola línea de código. Además, Swing aprovecha la circunstancia de que sus Componentes no están renderizados sobre la pantalla por el sistema operativo para soportar lo que llaman "pluggable look and feel", es decir, que la apariencia de la aplicación se adapta dinámicamente al sistema operativo y plataforma en que esté corriendo.

AWT y swing

2008-05-28T00:14:00.000-07:00

Hoy vamos hablar de AWT y swing, AWT es una libreria de Java para crear la parte grafica (Ventanas , Botones , etc) y swing es una extensión o mejora de AWT , en el esquema que tenemos en la foto de la entrada tenemos la herencia de clases, como podeis ver todas las clases heredan de Componet, bien expliquemos un poco.

Container: Es un contenedor y por lo tanto, también puede contener a mas container, para simplificarlo seria la ventana de la interfaz grafica. Se utiliza junto a un Layout ( ahora explicaremos que es un Layout ) , permitiendo que aparezcan varios objetos en nuestras interfaces para el usuario.Hay dos tipos de clases que heredan de Container Window y Panel, Window es la clase de la tipica ventana que estamos acostumbrados a ver, Panel como su propio nombre indica es un simple Panel sin botones maximizar, minimizar , cerrar.

Como ya comentamos antes ,cada Container tiene su Layout que sirve para administrar la posicion de los componentes dentro de un Container , Aqui teneis el enlace a la interfaz LayoutManager de las API de java.

De Component tambien heredan una serie de clases que sirven para crear Botones , campos de textos , Listas , etc... objetos que permiten que el usuario se comunique con nuestra aplicación.

¿Como manejar el blog usando Java?

2008-05-27T02:25:00.000-07:00

Esta aplicación a la cual le voy a dedicar esta entrada tiene como finalidad poder acceder a un blog , mediante las API java de Blogger (que permite a un programa java conectarse a nuestro blog para pedir las entradas o publicar nuevas) para ello usaremos estas clases e interfaz.

GmailUsuario

Sirve para almacenar la cuenta y la clave del usuario del blog.

Atributos:

cuentaMail (String)

clave (String)

Enlace a la clase

EntradaBlog:

Clase para almacenar una entrada de blog.

Atributos

titulo (String)
contenido (String)

Enlace a la clase

ServicioBloggerImpl

Clase que implementa la interface ServicioBlogger (tiene como metodo conectar(GmailUsuario)) , esta clase se usa para conectar con el blog y recibir las entradas usando las API.

Metodos:

conectar:Devuelve un objeto ConexionBlogger.

Requiere un objeto de clase GoogleService que a su vez este objeto como parametro necesita el usuario y la clave que tenemos almacenado en un objeto de clase GmailUsuario.

dameEntradas: Devuelve una Colección de Entradas.

Requiere una Colección de tipo EntradaBlog , un objeto de clase Feed(objecto donde estan almacenadas todas las entradas del Blog con su cuerpo y su titulo) y uno de clase URL que le asignaremos la ruta del blog para mas tarde cargar a nuestro objeto Feed con todas las entradas del blog y poder trabajar con ellas.

Enlace a la clase

CLASES DE EXCEPCIONES

ErrorBlogger

BlogNoExistenteException

ErrorConexion.java

En el enlace al repositorio podreis ver las pruebas realizadas y el proyecto entero:

Repositorio

Colecciones Tipos y formas de Recorrerla.

2008-05-23T08:44:00.000-07:00

Java tiene tres interfaces de colecciones Map, List y Set a continuación explicare cada una de ellas:

Map: Interfaz de colección de elementos pares los cuales van con una clave y un valor muy utiles cuando se quiere hacer una busqueda por la clave.

Set: Interfaz que como pecualiaridad tiene que no deja meter dos elementos en las colecciones iguales.

List:La ordenación es la característica más importante de una Lista, asegurando que los elementos siempre se mantendrán en una secuencia concreta.

Para ordenar elementos List podemos usar el método sort() de la clase java.util.Collections. Podemos pasarle al método un objeto con la interaz List, o podemos pasarle un objeto con la interfaz List y un Comparator. Si los elementos de la coleción List son todos del mismo tipo de clase y esa clase implementa el interface Comparable, simplemente podemos llamar a Collections.sort().

public static class Comparando
    implements Comparator {
  public int comparar(Object elemento1,
      Object elemento2) {
    String lower1 =
      element1.toString().toLowerCase();
    String lower2 =
      element2.toString().toLowerCase();
    return lower1.compareTo(lower2);
  }
}

TreeSet es una clase que utiliza la interfaz Set y que sirve para ordenar la colección segun como definas el metodo compareTo() de la interfaz comparable que hay que implementar , que comfiguremos al crearnos el objeto TreeSet.

Las formas de recorrerla son varias:

Tipico for ejemplo:
for(int i=0; i Object o = lista.get(i); System.out(o); }

Desde i = 0 hasta que i sea mayor o igual que la magnitud de la lista imprime el elemento Object de la lista.

foreach: Por cada elemento de la lista tipo Alumno imprime el elemento de la lista:

foreach(Alumno al:lista){ System.out(al.getNombre()); }

Itinerator:Usando un objeto de clase Iterator podemos recorrer la coleccion por el indice:

List pruebaItinerator = new LinkedList();

for (Iterator iterator = pruebaItinerator.iterator(); iterator.hasNext();) {
String t = (String) iterator.next();

}

Programación usando pruebas

2008-05-23T08:16:00.000-07:00

Hola buenas hoy vamos a ver otra forma de programar usando el pluggin TestNG , para ello nos crearemos una carpeta Soucer aparte de src llamada test donde tendremos la misma estructura de paquetes que la clases que queramos probar por ejemplo:

Poniendo la misma estructura de paquetes y bajandote e instalando el pluggin TestNG y la libreria podremos probar nuestro codigo incluso antes de crearlo mediante el metodo assert() que se encarga de asegurar que la condicion que le pasas entre parentesis es cierta ejemplo:

@Test
public void pruebaCalendar() {
Calendar fecha = Calendar.getInstance();
assert (fecha.get(Calendar.YEAR) == 2008);
}

Ya comentamos en la entrada anterior que para que el TestNG testee un trozo de codigo debemos poner @Test encima del metodo o clase.Bien explico el ejemplo creamos un objeto de clase Calendar por defecto Calendar coje la fecha del sistema si no la modificamos, por eso podemos asegurar que el año de nuestro objeto Calendar es 2008 y ya estamos seguro de que en cualquier momento , que usemos ese codigo el valor del año sera 2008 ya que TestNG si no es cierto te lo indica.

Ventajas: Las ventajas son de mucho valor ya que te aseguras de todo lo que estas programando constantemente y puedes probar que tu codigo siempre esta bien y al final siempre te ahorras tiempo de debug que en algunos casos se hace bastante pesado.

Desventaja:Al principio quizas se hace un poco pesado estar probando cada trozo de tu codigo y eso hace que te relentices un poco programando.

La estructura de paquetes sirve para no tener que importar las clases y poder acceder a los atributos y metodos que no sean private y el escenario de prueba es donde se declaran los objetos que mas tarde usaremos en la prueba , ejemplo:

@Test
public void pruenaAlumno(){
////////// Escenario de pruebas
Alumno a1= new Alumno();
Alumno a2= new Alumno();
////////// FIN Escenario de pruebas
boolean res= a1.equals(a2);

assert(b):"No son iguales"

}

Anotaciones @Test ,@BeforeTest , @AfterTest

2008-05-17T09:42:00.000-07:00

Buenas hoy voy hablar de estas anotaciones en especial ya que me parecen interesantes y la vereis amenudo en mi codigo (si no sabes que son las anotaciones mas abajo hay una entrada que lo explica) bien dicho esto comencemos:

@Test: Cuando tu haces una clase Test, para avisar que a de leer esa parte del codigo al Testing, colocamos @Test encima del metodo o clase que deseemos ,veamos el ejemplo:

@Test
public void pruebaOrden() {
coches.add(coche3);
coches.add(coche1);
Collections.sort(coches);
assert (coches.get(0).equals(coche1));
}

@BeforeTest: Cuando lo que deseas es que lea antes que @Test otro trozo de codigo colocas esta anotación, esta anotación es muy util para declarar variables antes de usarlas en los metodos que contienen una @Test, por ejemplo:

@BeforeTest
public void inicializarRecursos() {
coches = new ArrayList();
coche1 = new Coche("Opel", "Astra");
coche2 = new Coche("Opel", "Astra");
coche3 = new Coche("Renault", "T5");

}

@AfterTest:Y por ultimo cuando lo que quieres es que tu trozo de codigo selea despues del @Test colocas esta anotaión, es my util para limpiar las variables despues de un @Test, un ejemplo es:

@AfterTest
public void limpiarRecursos() {
coche1 = null;
coche2 = null;
coche3 = null;
coches = null;
}

Enumerations

2008-05-16T08:45:00.000-07:00

Hoy vamos a dedicarle la entrada a los objetos de clase Enumerations, dichos objetos tienen como finalidad organizar las constantes , expliquemoslo con un ejemplo :

Nos Creamos nuestro Objeto Enum tiene como valores constantes A,B,C y D que son los niveles de acceso

package eticom.nums;
/**
* @author Administrador
*
*/

public enum NivelDeAcceso {

A, B, C, D }

-------------------------------------------------------------------------------------------

Nos creamos la clase Acceso que tendra como atributo niveldeaceso un objeto de mi enums que creamos con anterioridad y redifiniremos el metodo equals para poder comparar el objeto(si tienes dudas de como se hace mas abajo esta la explicación)

package eticom;
import eticom.nums.NivelDeAcceso;

/**
* @author Administrador
*
*/
public class Acceso {

public NivelDeAcceso niveldeacceso;

/**
* Constructor por defecto
*/

public Acceso() {
}
/**
* Constructor que crea el objeto pasandole un objeto de clase enum
*
* @param nivelParametro
* Mandatory
*/
public Acceso(NivelDeAcceso nivelParametro) {
niveldeacceso = nivelParametro;
}
/**
* Redefinir Metodo Equals
*/

public boolean equals(Object a) {
boolean respuesta = false;
Acceso u = (Acceso) a;
if (u.niveldeacceso.equals(this.niveldeacceso)) {
respuesta = true;
};
return respuesta;
}
}
--------------------------------------------------------------------------------
Bien ahora nos crearemos la prueba y veremos la utilidad a todo esto, haremos una prueba que comparara un objeto de clase Acceso con otro de clase Acceso si quieres comparar Acceso literalmente y por algun casual te equivocas al escribir el valor ejemplo:

String admin = new String("Acceso A");
String usuario = new String("acceso A");

assert(admin.equals(usuario)):"No son iguales"

Dara fallo ya que uno empieza en mayusculas y otro en minuscula pero si nos creamos un enums estamos obligados a escoger un valor constante si no no compilara ,bien despues de esta parrafada hagamos la prueba:

/**
*
*/
package eticom;
/**
* @author Administrador
*
*/
import org.testng.annotations.Test;
import eticom.nums.NivelDeAcceso;

@Test

public class AccesoTest {

/**
* Prueba de la clase Acceso
*/
public void pruebaAcceso() {
Acceso admin = new Acceso(NivelDeAcceso.A);
Acceso usuario = new Acceso(NivelDeAcceso.B);
Acceso usuario2 = new Acceso(NivelDeAcceso.A);
assert (admin.equals(usuario2)) : "No tienen el mismo acceso";
assert (!admin.equals(usuario)) : "tienen el mismo acceso";
}
}

Interface Java

2008-05-15T03:39:00.000-07:00

Concepto:

El concepto de Interface , trata de una clase donde todos los métodos son abstractos . Permite al diseñador de clases establecer la forma de una clase (nombres de métodos, listas de argumentos y tipos de retorno, pero no bloques de código).

Para crear una interface, se utiliza la palabra clave interface en lugar de class. La interface puede definirse public o sin modificador de acceso, y tiene el mismo significado que para las clases. Todos los métodos que declara una interface son siempre public.

Para indicar que una clase implementa los métodos de una interface se utiliza la palabra clave implements. El compilador se encargará de verificar que la clase efectivamente declare e implemente todos los métodos de la interface. Una clase puede implementar más de una interface.

Declaración y uso

Una interface se declara:

interface nombre_interface {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
. . .
}

Por ejemplo:

interface Bailarin{
void bailar();

}

Y una clase que implementa la interface:

class Persona extends Object implements Bailarin{
String tipoDeBaile;
public String bailar(String tipo) {
tipoDeBaile=tipo;
return "El tipo de baile que baila este bailarín es:"+tipoDeBaile;
}

}

Java te permite crear un objeto de una clase pero usando su interface de esta manera si por algun casual cambias la clase no se modificaria el codigo , simplemente implementariamos la interface a la nueva case, ejemplo:

Nos estamos creando el objecto a de clase persona pero usando la interface en este caso si cambiamos la clase y hacemos una nueva ,llamada Persona2 no cambiariamos el codigo (a.bailar("Tango");) solo cambiariamos (Bailarin a = new Persona2();) ya que al usar la interface te obliga a usar solo los metodos redefinidos de la interface en la clase.
Bailarin a = new Persona();

a.bailar("Tango");

Redefinir el metodo Equals

2008-05-13T23:16:00.000-07:00

Muy buenas hoy vamos a ver como se redefine el metodo equals de la clase objects para poder utilizarlos en nuestra clase, para ello nos crearemos nuestra clase y definimos un metodo equals de este modo:

package eticom;
import eticom.anotaciones.Desarrollador;

@Desarrollador(nombre="Alberto")
public class Usuario {

String nombre;
String clave;

public Usuario() {
nombre="Jesus";
clave="1111";

}

public Usuario(String nombre, String clave) {
this.nombre = nombre;
this.clave = clave;

}
/*
Al llamarlo igual que el metodo de la clase Object redefiniremos el metodo pasandole un objeto y haciendo un casting al object para convertirlo en obejeto de nuestra clase.

*/
public boolean equals(Object a) {
boolean respuesta=false;
Usuario u = (Usuario)a;
if(u.nombre.equals(this.nombre)&& u.clave.equals(this.clave)){
respuesta=true;

};
return respuesta;

}

}

Hagamos la prueba:

package eticom;

import org.testng.annotations.Test;

import eticom.anotaciones.Desarrollador;
import eticom.anotaciones.FechaProyecto;

public class UsuarioTest {
String nombre;
String clave;

public UsuarioTest() {

}

public UsuarioTest(String nombre, String clave) {
this.nombre = nombre;
this.clave = clave;

}

@Test
public void pruebaEquals() {
Usuario uno = new Usuario();
Usuario dos = new Usuario();
assert (uno.equals(dos)) : "No son iguales";
Usuario tres = new Usuario("pepe", "3333");
Usuario cuatro = new Usuario("juan", "7777");
assert (!tres.equals(cuatro)) : "Son iguales";
}
}

Anotaciones

2008-05-12T23:46:00.000-07:00

Las anotaciones son un mecanismo para dotar a las clases de Meta información.

Para acceder a la información de una anotación en tiempo de ejecución utilizamos el API de reflexión: java.reflection, que se ha completado en Java 5 para tener acceso a las anotaciones.

Las anotaciones se utilizan para anotar nuestro código, y la información de la anotación puede estar relacionada con la seguridad (permisos, usuarios, roles), persistencia (transacciones, cache, tablas, esquemas ...), logging ... dando lugar a un nuevo complemento de la POO, la Programación Orientada a Atributos

Un ejemplo de anotacion:

Esta es la anotacion que nos creamos
-----------------------------------------------------
package eticom.anotaciones;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface Desarrollador {

String nombre();

}

---------------------------------------------------------------
Y aqui en la clase UsuarioTest es donde la usamos
--------------------------------------------------------------
package eticom;

import org.testng.annotations.Test;

import eticom.anotaciones.Desarrollador;

public class UsuarioTest {

@Test
public void pruebaAnotacionAutorExiste(){
assert(Usuario.class.isAnnotationPresent(Desarrollador.class)):" no existe la anotación";
Desarrollador annotation = Usuario.class.getAnnotation(Desarrollador.class);
assert(annotation.nombre().equals("Juan")):" no coincide el valor con Juan";
}

}

Etiquetas JSF , Seam y AJAX

2008-05-08T23:24:00.000-07:00

JSF
Este primer enlace es de JSF y te viene como son los tags en JSF y como serian en HTML esta bastante bien ya que para el que sepa HTML le sera muy facil entenderlos :)

http://www.exadel.com/tutorial/jsf/jsftags-guide.html

SEAM
Bien aqui teneis un manual de Seam una tecnología que tiene mucho que decir, para el que no conozca esta tecnología ,Seam es un producto creado por Gavin King el creador de Hibernate y que busca la creación rápida de aplicaciones web java:

http://docs.jboss.com/seam/2.0.0.GA/reference/en/html
/index.html

AJAX
Definicion:AJAX, acrónimo de Asynchronous JavaScript And XML (Javascript asíncrono y XML), es una técnica de desarrollo web para crear aplicaciones interactivas o (Rich Internet Applications). Éstas se ejecutan en el RIA cliente, es decir, en el navegador de los usuarios y mantiene comunicación asíncrona con el servidor en segundo plano. De esta forma es posible realizar cambios sobre la misma página sin necesidad de recargarla. Esto significa aumentar la interactividad, velocidad y usabilidad en la misma.

http://labs.jboss.com/file-access/default/members/
jbossajax4jsf /freezone/docs/devguide/index.html

Master Java

2008-05-08T08:36:00.000-07:00

Hola buenas me presento , me llamo Alberto y estoy iniciando mi camino como programador .En este blog ire añadiendo los conocimientos que adquiera en el nuevo curso de Java que comenzare hoy y en las practicas de empresa que efectuo en la empresa Viavansi