miércoles, mayo 21, 2008

EJB3 development (Primera Parte)

Bueno, continuando con las pequeños howto, ahora vamos a realizar un pequeño ejemplo del uso de EJB3. El ejemplo se basara en algo simple, un modelo de datos de tres tablas relacionales. Pero primero espesaremos viendo que cosa es EJB.

EJB o "Enterprise Java Beans", es una API java para la construcción de aplicaciones empresariales JEE, En palabras simples los EJB son componentes desde el lado del servidor que encapsulan la lógica de negocio de la aplicación. para mas info aca.

Espesaremos creando un proyecto maven, para hacer el modelo de datos :
~$mvn archetype:create -DgroupId=org.app.ejb -DartifactId=ejb-security -DarchetypeArtifactId=maven-archetype-quickstart
~$mvn eclipse:eclipse
Luego creamos un package llamado "model", donde dejaremos todos los entity de nuestro proyecto.

Ahora, agregamos las siguientes dependencias a nuestro proyecto maven :

* ejb-api 3.0
* jsr250-api
* persistence-api

Además de agregar lo siguiente al pom.xml :
<build>
<plugins>
...
<plugin>
<groupid>org.apache.maven.plugins</groupid>
<artifactid>maven-ejb-plugin</artifactid>
<configuration>
<ejbversion>3.0</ejbversion>
</configuration>
</plugin>
</plugins>
</build>


Dentro del package "model" crearemos tres classes , las cuales se llamaran de la siguiente forma :

* User
* UserLogin
* UserState

Ahora estas classes tendrán las siguiente relación :

User 1-n UserLogin
User 1-1 UserState

Ahora creamos las tres classes y a cada una le ponemos la siguiente annotations. Las classes debieran quedar de la siguiente forma :
...
import javax.persistence.Entity;
...
@Entity
public class User implements Serializable {
...
}

...
import javax.persistence.Entity;
...
@Entity
public class UserLogin implements Serializable {
...
}

...
import javax.persistence.Entity;
...
@Entity
public class UserState implements Serializable {
...
}

Luego en cada classe creamos los siguientes atributos con get y set y estas debieran quedar de la siguiente manera :
...

@Entity
@Table(name = "CA_USER")
public class User implements Serializable {

/**
*
*/
private static final long serialVersionUID = -427916813479074007L;

private Integer _id;

private String _name;

private UserState _stateId;

private Set<userlogin≶ _login;

@Id()
@Column(name = "USER_ID", nullable = false)
public Integer getId() {
return _id;
}

public void setId(Integer id) {
_id = id;
}

@Column(name = "USER_NAME", nullable = false)
public String getName() {
return _name;
}

public void setName(String name) {
_name = name;
}

@OneToOne(optional = false)
@JoinColumn(name = "STATE_ID", unique = true, nullable = false, updatable = false)
public UserState getStateId() {
return _stateId;
}

public void setStateId(UserState stateId) {
_stateId = stateId;
}

@OneToMany
@JoinColumn(name = "LOGIN_ID", unique = true, nullable = false, updatable = false)
public Set<userlogin≶ getLogin() {
return _login;
}

public void setLogin(Set<userlogin≶ login) {
_login = login;
}

}

...

@Entity
@Table(name = "CA_USER_STATE")
public class UserState implements Serializable {

/**
*
*/
private static final long serialVersionUID = -7316954246334750548L;

private Integer _id;
private String _name;
private Set<user≶ _user;

@Id
@Column(name = "STATE_ID", nullable = false)
public Integer getId() {
return _id;
}

public void setId(Integer id) {
_id = id;
}

@Column(name = "STATE_NAME", nullable = false)
public String getName() {
return _name;
}

public void setName(String name) {
_name = name;
}

@ManyToOne(optional = false)
@JoinColumn(name = "STATE_ID", unique = true, nullable = false, updatable = false)
public Set<user&l; ggetUser() {
return _user;
}

public void setUser(Set<user≶ user) {
_user = user;
}

}

...

@Entity
@Table(name = "CA_USER_LOGIN")
public class UserLogin implements Serializable {

/**
*
*/
private static final long serialVersionUID = 4376480932546830177L;

private Integer _id;
private String _login;
private String _password;
private User _user;

@Id
@Column(name = "LOGIN_ID", nullable = false)
public Integer getId() {
return _id;
}

public void setId(Integer id) {
_id = id;
}

@Column(name = "LOGIN_NAME", nullable = false)
public String getLogin() {
return _login;
}

public void setLogin(String login) {
_login = login;
}

@Column(name = "LOGIN_PASSWORD", nullable = false)
public String getPassword() {
return _password;
}

public void setPassword(String password) {
_password = password;
}

@ManyToOne
@JoinColumn(name = "USER_ID", unique = true, nullable = false, updatable = false)
public User getUser() {
return _user;
}

public void setUser(User user) {
_user = user;
}

}
Si observan bien las classes agregue unas anotaciones en los methodos y classe los cuales los voy a explicar ahora :

* @Entity: Define que la classe en un entity
* @Table : Define lo atributos de la tabla
* @Id : Define que un atributo es clave primaria
* @Column : Define loa tributos de la columna de la tabla
* @ManyToOne, @OneToMany, @OneToOne : Define la relacion del atributo
* @JoinColumn : Define la estructura de la relacion

Ahora, ya que tenemos los entitys creados, creamos nuestro archivo de configuración el cual definida nuestro persistencia para poder crear nuestro ejb.

Dentro de la ubicación "src/main/resouces/META-INF, creamos un archivo llamado "persistence.xml", el cual debe ser de la siguiente forma :
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
version="1.0">
<persistence-unit name="em" transaction-type="JTA">
<jta-data-source>jdbc/sampleDS</jta-data-source>
<class>org.app.ejb.model.user.User</class>
<class>org.app.ejb.model.user.login.UserLogin</class>
<class>org.app.ejb.model.user.state.UserState</class>

<properties>
<property name="hibernate.dialect"
value="org.hibernate.dialect.HSQLDialect" />
<property name="hibernate.hbm2ddl.auto" value="create-drop" />
</properties>

</persistence-unit>
</persistence>
Si observan el archvio, en el definimos las classes y la conexion para que estas se conexten.

Con esto ya completamos la primera parte. En la segunda crearemos los ejb para usar estos entitys.

suerte

sábado, mayo 17, 2008

Maven development (Segunda Parte)

Hello

Bueno continuando con la primera parte de maven...ahora vamos a crear un proyecto, asociarlo a nuestro IDE favorito y agregar dependencia a nuestro proyecto, además de interactuar entre dos proyectos nuestros y crear test para estos.

Para empezar, creemos dos proyectos, uno sera una librería matemática (suma, resta...) y el otro sera el que ejecutara los proceso, algo simple pero sirve para entender a lo que voy.
$ mvn archetype:create -DgroupId=org.test.app -DartifactId=math-core
$ mvn archetype:create -DgroupId=org.test.app -DartifactId=math-logic
después de ejecutar estos comando se crearon dos proyectos , con la estructura que les mencione en el cap anterior.

Ahora en mi caso, en estos momento uso eclipse , pero igual me gusta netBeans, pero por costumbre me quedo con el primero. Asi creare los proyectos como eclipse.

Primero voy a las carpetas de los proyectos (math-core y math-logic) y ejecuto el siguiente comando , en los dos directorios :
math-core $ mvn eclipse:eclipse
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------

math-logic $ mvn eclipse:eclipse
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------

Después de hacer esto solo abrimos el eclipse y importamos estos dos proyectos , luego, borramos las librerías que genero en las propiedades de los proyectos y agregamos la libreria "MAVEN Manager Dependency". Si no esta la variable es por que no tienes el plugins de maven para eclipse, en ese caso instala esto. Después botón derecho sobre el proyecto y vas a la opción maven la habilitas.

Si prefieres netbeans cambia en el comando eclipse por netbeans y listo.

Continuando, ahora sobre el proyecto math-core trabajaremos primero, le agregaremos la librería "log4j", para manejar un log de los procesos.

Para hacer esto, botón derecho/Maven/Add Dependency, luego en esa ventana ponemos el nombre de la librería , la seleccionamos y listo, ya esta agregada.

Para verificar que se agrego la dependency, mirar el archivo pom.xml y en la parte de dependencias se debe haber agregado lo siguiente o algo parecido.

<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.9</version>
</dependency>



Después de esto creen una classe que contenga methodos, uno que sume, reste y multiplique, estos methodo que retornen el resultado y se pasen loa valores .

Ej:
(...)
public Integer suma(Integer x, Integer y) {
return x + y;
}

public Integer resta(Integer x, Integer y) {
return x - y;
}

public Integer mul(Integer x, Integer y) {
return x * y;
}

public Integer div(Integer x, Integer y) {
return x / y;
}
(...)


después de esto creamos los test para probar estos methodos. Dentro de la carpeta "src/test/java", Creamos una classe que llame a estas.

Ej :

package org.test.app;

import junit.framework.TestCase;

public class CalculatorTest extends TestCase {

private Calculator _cal;

private Integer x = 19;

private Integer y = 40;

public CalculatorTest() {
_cal = new Calculator();
}

public void testSuma() {
System.out.println("Suma : " + _cal.suma(x, y));
}

public void testResta() {
System.out.println("Resta : " + _cal.resta(x, y));
}

public void testMul() {
System.out.println("Mul : " + _cal.mul(x, y));
}

public void testDiv() {
System.out.println("Div : " + _cal.div(x, y));
}

}


Ejecutamos el test con el siguiente comando :

math-core $ mvn clean test

y la salida debiera ser algo así :
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running org.test.app.CalculatorTest
Suma : 59
Resta : -21
Mul : 760
Div : 0
Tests run: 4, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.304 sec

Results :

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


Ahora dentro de la classe que suma agregamos los methodos de las librerías para saber que hace el methodo al ser llamado, y esto lo hacemos usando la dependencia que le agregamos.

Como ya finalizamos. procedemos a instalar nuestra librería , para que esta pueda ser usada por otros proyectos , esto lo hacemos de la siguiente forma :

math-core $ mvn clean install


Al hacer esto, maven compila, corre nuestros test y instala el JAR del proyecto en nuestro repositorio local.

Como ya terminamos la librería que calcula, ahora trabajamos con el proyecto que la referencia "math-logic"

En este proyecto, agregamos la dependencia llamada "math-core", y con esto aparecerá dentro dentro de nuestro pom.xml lo siguiente :

<dependency>
<groupId>org.test.app</groupId>
<artifactId>math-corej</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
y con esto ya podemos utilizar la librería dentro de este proyecto.Asi que creamos una classe que se le entregen dos parametros y que llame a los methodo de la libreria .

Ej :
package org.test.app;

public class Main {

/**
* @param args
*/
public static void main(String[] args) {
Integer x = new Integer(args[0]);
Integer y = new Integer(args[1]);

Calculator cal = new Calculator();
cal.suma(x, y);
cal.resta(x, y);
cal.mul(x, y);
cal.div(x, y);
}

}
Ahora, piensen que este ultimo proyecto puede ser un proyecto WEB o GUI y por medio de una interface le entreguen los parámetros a otra librería.

y con esto esta listo, creamos un test y llamamos desde acá a las methodos de calculo

bueno, con esto termine el pequeño manual de Maven.

Suerte...

miércoles, mayo 07, 2008

Maven development (Primera Parte)


En estos pequeños how to no voy a habla ni de historia ni voy a entrar tan a fondo, eso se los dejo a ustedes, Yo voy crear un proyecto usando MAVEN. y si tienen dudas me consultan o googlean...;-)

Pero que puedo hacer con maven, bueno todo esto :

* Builds
* Documentacion
* Reporting
* Dependencies
* SCMs
* Releases
* Distribucion

En si el uso de maven es simple, uno maneja las dependencias del proyecto, las versiones de este, en un archivo centralizado. este archivo se llama pom.xml y debe quedar en el / del proyecto.

Maven maneja una estructura de directorio que es de la siguiente forma :
/pom.xml
/src
..../main
......../java
..............(package)
......../resources
................../META-INF
..................(properties)
......../webapp
................./WEB-INF
................(pagina web)
..../test
........./java
........./resources
La cantidad de carpetas va depender del tipo de proyecto que creen, maven soporta creación de : JAR, WAR, EJB, EAR.

Instalar :

Primero, para usar maven se debe descargar y luego descomprimir donde a uno mejor le acomode ($MAVEN_HOME). Después de descomprimir se debe setear al PATH la carpeta $MAVEN_HOME/bin, además de setear como variable de ambiente el JAVA_HOME, después de hacer esto solo basta ejecutar lo siguiente y les debiera salir algo parecido.
iflores@slacker ~ $ mvn -version
Maven version: 2.0.8
Java version: 1.6.0_06
OS name: "linux" version: "2.6.24-16-generic" arch: "i386" Family: "unix"
Si les salio esto, maven ya esta listo para usarse en su ambiente de desarrollo.

Mi primer proyecto maven :

Para crear un proyecto maven existen varias tipos de creación dependiendo de la archetype (arquitectura), la creación básica es de la siguiente forma :
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-app
En este caso nuestra aplicación seria un JAR, nuestros proyecto se llamaría "my-app" y nuestra ubicación en repositorio seria "com.mycompany.app".

Creemos nuestro primer proyecto, el cual se llamara "mavenTest" y su ubicación sera "org.maven.app", así que ejecutamos el siguiente comando para crear el proyecto

iflores@slacker workspace $ mvn archetype:create -DgroupId=org.maven.app -DartifactId=mavenTest
....
[INFO] BUILD SUCCESSFUL
...


Luego si vemos la ubicación donde ejecutamos el proyecto se creo una carpeta llamada "mavenTest",dentro de esta nos creo lo siguiente.

mavenTest
|-- pom.xml
`-- src
|-- main
| `-- java
| `-- org
| `-- maven
| `-- app
| `-- App.java
`-- test
`-- java
`-- org
`-- maven
`-- app
`-- AppTest.java


Ahora si vemos el archivo pom.xml, este quedo de la siguiente forma :

<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.maven.app</groupId>
<artifactId>mavenTest</artifactId>

<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>Maven Quick Start Archetype</name>
<url>http://maven.apache.org</url>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>

<scope>test</scope>
</dependency>
</dependencies>
</project>



Si miramos mas a fondo el POM, en este archivo se definió el groupId y artifactId, que definimos en la creación, además de la versión que por defecto es 1.0-SNAPSHOT, además del tipo de packaging, que en este caso es JAR. Estos parámetros si uno los desea los puede cambiar, al igual que la versión. cada ves que uno hace un install del proyecto este se instala en el repositorio local que genera el MAVEN en ~/.m2 y ahí queda nuestro JAR, WAR o EAR creado, con la versión que le generamos, si cambiamos la versión se instala una nueva con la nueva versión y se conserva la anterior en el repositorio. Para una completa referencia del POM ver esto

Ahora ya con la estructura creada ya puedo empezar a desarrollar dentro de los directorios creados dejando en :
src/main/java : Las classes java
src/main/resources : Los properties o archivos de configuración para el JAR
src/test/java : Los test para las classes JAVA


Después de haber creado unas classes probemos el build del maven, para empaquetar el proyecto solo ejecutamos el siguiente comando :

mvn package


y el comando debiera terminar de la siguiente forma :

...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 11 seconds
[INFO] Finished at: Thu May 08 22:53:09 CLT 2008
[INFO] Final Memory: 5M/17M
[INFO] ------------------------------------------------------------------------


Y maven nos crea una carpeta llamada "target" en el proyecto y dentro de esta nos deja el JAR, que fácil !!!!.

que otros comando puedo ejecuta con maven, bueno acá hay algunos mas :

1. validate
2. generate-sources
3. process-sources
4. generate-resources
5. process-resources
6. compile

Para mas información sobre el build de maven ver esto.

Bueno con esto concluyo la primera parte de este howto, en la segunda parte hablare sobre las dependencias, test, integración con IDES.

Suerte

Mas info :

* Maven Getting Started Guide.
* Maven in 5 Minutes.

Maven2 + ejb3 + Struts2 + velocity

Hello

Bueno estos días he estado pensando en mi blog y analizando el flujo de gente que lo ve, y es mas de la que me esperaba (30 visitas diarias), Así que decidí volverlo un poco mas practico, con lo cual voy a espesar a publicar pequeños tutoriales , primeramente voy a empezar con lo siguiente :

* Maven2 : Crear un proyecto y manejar sus dependencias
* Ejb3 : Crear un pequeño modelo de datos con ejb3
* Struts2 : Un pequeño proyecto jee con struts2 usando lo anterior.
* Velocity : Crear pagina con velocity, macros

Bueno esto es para empezar y ver si la gente pika y hace consultas para ir viendo otras cosas mas, me voy a centrar primera mente en tópicos de desarrollo ya que es lo que hago mas a menudo, luego iré viendo que otros tópicos tomo, y si me hacen comentarios sobre otros temas realizare unos pequeños tutoriales, así que esperen que los realizare en este mismo orden.

suerte...

Abiertos los repositorios de Ubuntu 8.10


Hello

bueno para los que les guste trabajar con las versiones inestables de las distros en linux, ubuntu ya abrió el repositorio para la nueva versión de esta popular distro "Intrepid Ibex", la cual sera liberada en Octubre , bueno para los que quieran hacer esto si están en "Hardy" solo reemplacen esta palabra en su /etc/apt/source.list por "intrepid" y luego hacen un

sudo apt-get update && apt-get dist-upgrade


y listo ya están llenos de bugs....;-)

bueno yo les recomiendo que hagan esto en agosto ya que como 2 meses antes de la liberación de la versión final ya esta todo mas estable...

suerte