Introduccion a DART

Dart es un lenguaje de programación de código abierto, desarrollado por Google. La última versión estable hasta el momento (26/06/2019) es la 2.2.0.

Para realizar pruebas de conceptos y desarrollar algunas cosas es posible usar la página https://dartpad.dartlang.org. La página anterior nos presenta, si es que es la primera vez que entramos, un ejemplo ejecutable que demuestra los primeros elementos de DART, con oprimir el botón Run, hubicado en la parte central superior, vemos que se despliegan los valores hello1, hello2, etc. en la consola.


Para establecer un punto de entrada al código se requiere escribir el método main, el cual se define como una funcion que no acepta ni devuelve algún valor.

void main(){
}

Para imprimir en pantalla algún valor se usa la función print(), por lo que es válido realizar lo siguiente:

void main(){
   print("Hola desde DART");
}

Para iniciar, existen los tipos de datos:
int y double: Como tipo numérico
String: Como tipo para almacenar cadenas
bool: Como tipo de datos boolean
var: Para definir un tipo dinámico

Por lo que es posible declarar he inicializar variables en la misma línea de código como:

void main() {
  int edad = 10;
  double sueldo = 100.50;
  String nombre="Pepe";
  bool casado = false;
  var domicilio = "Calle desconocida #44";
}

Los tipos datos son intuitivos, int y double para almacenar números enteros y reales respectivamente; String para almacenar cadenas de texto, bool para almacenar los valores true o false y var para tipos dinámicos, es decir que puede almacenar cualquier cosa (Object en otros lenguajes de programación como Java).

Si ejecutamos en código anterior en dartpad obtenemos los mensajes:



Son mensajes informativos los cuales nos indican que las variables no están siendo usadas en ninguna parte del programa, por lo que si tenemos un programa mas extenso podríamos borrarlas sin problema, para que el mensaje desaparezca es suficiente con mandar a imprimir cada una con la función print();

void main() {
  int edad = 10;
  double sueldo = 100.50;
  String nombre="Pepe";
  bool casado = false;
  var domicilio = "Calle desconocida #44";
  
  print(edad);
  print(sueldo);
  print(nombre);
  print(casado);
  print(domicilio);
}

Como una introducción a DART es suficiente. Es posible realizar algunos cambios al código y realizar pruebas desde el navegador.

Suerte.

Claves Compuestas JPA

Aquí se muestra un ejemplo de como manejar las claves compuestas en JPA, para este caso se usa de inicio las anotaciones @IdClass y @EmbeddedId.

La estructura de la tabla es la siguiente, la tabla pue`e quedar mas completa añadiendo o eliminando campos pero solo es para mostrar el uso de la llave compuesta
Aquí se puede ver la clave compuesta con los campos folio y serie. Creamos la clase que representa la clave compuesta

public class IdFactura implements Serializable{
 private int folio;
 private String serie;
 
 public IdFactura(int folio, String serie) {
  super();
  this.folio = folio;
  this.serie = serie;
 }
}

Cabe señalar que la clase IdFactura no esta escrita o no se añade alguna anotacion en particular, solo contiene las propiedades y constructores, ahora se genera la entidad Factura

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.dracof.jpa.IdFactura;

@Entity
@Table (name="Factura")
@IdClass (IdFactura.class)
public class Factura implements Serializable {
 @Id
 @Column
 private int folio;
 
 @Id
 @Column
 private String serie;
 
 @Column
 private String emisor;
 
 @Column
 @Temporal (TemporalType.DATE)
 private Date fecha;
 
 //setters & getters
}

Aquí escribimos @IdClass (IdFactura.class) para indicar que haremos uso de la clase IdFactura para representar a la llave compuesta Se genera el cliente para realizar la inserción y la consulta

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.dracof.jpa.entities.Factura;

public class Cliente {
 public static void main(String[] args) {
  
  int folio = 1;
  String serie = "B";
  
  Cliente cliente = new Cliente();
  cliente.generaFactura(folio, serie);
  cliente.consultaFactura(folio, serie);
 }
 
 private void generaFactura(int folio, String serie) {

  System.out.println("Insertando Factura...");
  EntityManagerFactory emf = null;
  EntityManager em = null;
  Factura factura = new Factura();

  factura.setFolio(folio);
  factura.setSerie(serie);
  factura.setEmisor("Empresa X");
  factura.setFecha(null);
  try {
   emf = Persistence.createEntityManagerFactory("unitPersistence");
   em  = emf.createEntityManager();
   
   em.getTransaction().begin();
   em.persist(factura);
   em.getTransaction().commit();
   System.out.println("Factura insertada correctamente");
  } catch (Exception e) {
   System.out.println("Existe un error al insertar factra");
   em.getTransaction().rollback();
   e.printStackTrace();
  } finally {
   em.close();
   emf.close();
  }
 }
 
 private void consultaFactura(int folio, String serie) {
  System.out.println("Consultando Factura...");

  EntityManagerFactory emf = null;
  EntityManager em = null;
  
  IdFactura idFactura = new IdFactura(folio, serie);
  try {
   emf = Persistence.createEntityManagerFactory("unitPersistence");
   em  = emf.createEntityManager();
   
   
   Factura factura = em.find(Factura.class, idFactura);
   System.out.println("Folio:  " + factura.getFolio());
   System.out.println("Serie:  " + factura.getSerie());
   System.out.println("Emisor: " + factura.getEmisor());
   System.out.println("Fecha:  " + factura.getFecha());
  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   em.close();
   emf.close();
  }
 }
}

Y vemos el resultado de ejecutar el cliente

Insertando Factura...
Factura insertada correctamente
Consultando Factura...
Folio:  1
Serie:  B
Emisor: Empresa X
Fecha:  null

Ahora se realizan algunos cambios para hacer la prueba con @EmbeddableId Se modifica la clase IdFactura de la siguiente forma

@Embeddable
public class IdFactura implements Serializable {
 @Column
 private int folio;
 
 @Column
 private String serie;
 
 public IdFactura() {
 }
 
 public IdFactura(int folio, String serie) {
  super();
  this.folio = folio;
  this.serie = serie;
 }

 public int getFolio() {
  return folio;
 }

 public String getSerie() {
  return serie;
 }

//en este caso omiti los setters para convertir la clase en inmutable
}

Se nota que ahora la clase IdFactura se anota con @Embeddable y los campos folio y serie ahora contienen @Column, hay que recordar que como los campos serie y folio se llaman igual que los campos de la tabla podemos omitir el parámetro name de Column

import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.dracof.jpa.IdFactura;

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

 @EmbeddedId
 private IdFactura idFactura;
 
 @Column
 private String emisor;
 
 @Column
 @Temporal (TemporalType.DATE)
 private Date fecha;

 public IdFactura getIdFactura() {
  return idFactura;
 }

 public void setIdFactura(IdFactura idFactura) {
  this.idFactura = idFactura;
 }

 public String getEmisor() {
  return emisor;
 }

 public void setEmisor(String emisor) {
  this.emisor = emisor;
 }

 public Date getFecha() {
  return fecha;
 }

 public void setFecha(Date fecha) {
  this.fecha = fecha;
 }
}

Observamos que ahora para representar la llave compuesta dentro de Factura se usa @EmbeddedId y usamos IdFactura como una propiedad. El cliente se modifica ligeramente quedando

public class Cliente {
 public static void main(String[] args) {
  ...
 }
 
 private void generaFactura(int folio, String serie) {
  ...
  Factura factura = new Factura();
  IdFactura idFactura = new IdFactura(folio, serie);
  
  factura.setIdFactura(idFactura);
  factura.setEmisor("Empresa X");
  factura.setFecha(null);
  ...
 }
 
 private void consultaFactura(int folio, String serie) {

  // no sufre cambios
 }
}

Obteniendo el mismo resultado

Insertando Factura...
Factura insertada correctamente
Consultando Factura...
Folio:  1
Serie:  B
Emisor: Empresa X
Fecha:  null

Ahora realizamos el ejercicio usando solo XML, entonces borramos todas las anotaciones y la configuración del XML usando id-class y embeddable respectivamente

<entity-mappings>
    <entity class="org.dracof.jpa.entities.Factura">
     <table name="Factura"/>
     <id-class class="org.dracof.jpa.IdFactura"/>
     <attributes>
      <id name="folio">
       <column/>
      </id>
      <id name="serie">
       <column/>
      </id>
      <basic name="emisor">
       <column/>
      </basic>
      <basic name="fecha">
       <temporal>DATE</temporal>
       <column/>
      </basic>
     </attributes>
    </entity>
</entity-mappings>

y

<entity-mappings>
    <embeddable class="org.dracof.jpa.IdFactura">
     <attributes>
      <basic name="folio">
       <column/>
      </basic>
      <basic name="serie">
       <column/>
      </basic>
     </attributes>
    </embeddable>
    <entity class="org.dracof.jpa.entities.Factura">
     <table name="Factura"/>
     <attributes>
      <embedded-id name="idFactura"/>
      <basic name="emisor">
       <column/>
      </basic>
      <basic name="fecha">
       <temporal>DATE</temporal>
       <column/>
      </basic>
     </attributes>
    </entity>
</entity-mappings>

La estructura del proyecto quedo como sigue Suerte.

Creación de una entidad en JPA

En este ejercicio se muestra la creación de una Entidad en JPA usando la base de datos SQLite y realizando operaciones de inserción y consulta.

Creacion de la tabla Persona
Creación de la clase Persona que representa a la tabla anteriormente mencionada

public class Persona {
 private int idPersona;
 private String nombre;
 private String apellidoPaterno;
 private String apellidoMaterno;
 private Date fechaNacimiento;

 //setters &aip; getters 
}

Como se puede observar es una clase plana con propiedades, setters y getters comunes. Para crear la entidad usaremos las anotaciones @Entity, @Table, @Id, @Column y @Temporal de la siguiente manera

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table (name="Persona")
public class Persona {
 
 @Id
 @Column (name="id_persona")
 private int idPersona;
 
 @Column
 private String nombre;
 
 @Column (name="apellidop")
 private String apellidoPaterjo;
 
 @Column (name="apellidom")
 private String apellidoMaterno;
 
 @Column (name="fecha_nac")
 @Temporal (TemporalType.DATE)
 private Date fechaNacimiento;

 //setters & getters 
}

Cuando el nombre de la propiedad coincide con el nombre de la columna es posible omitir el parámetro name de Column, para este ejemplo el único campo que coincide es “nombre”, lo mismo pasa con el @Table, si el nombre de la clase coincide con el nombre de la tabla se puede omitir Es posible colocar las anotaciones en los métodos en lugar de propiedades, quedando

@Entity
@Table (name="Persona")
public class Persona {
 
 private int idPersona;
 private String nombre;
 private String apellidoPaterno;
 private String apellidoMaterno;
 private Date fechaNacimiento;
 
 @Id
 @Column (name="id_persona")
 public int getIdPersona() {
  return idPersona;
 }
 public void setIdPersona(int idPersona) {
  this.idPersona = idPersona;
 }
 
 @Column
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 
 @Column (name="apellidop")
 public String getApellidoPaterno() {
  return apellidoPaterno;
 }
 public void setApellidoPaterno(String apellidoPaterno) {
  this.apellidoPaterno = apellidoPaterno;
 }
 
 @Column (name="apellidom")
 public String getApellidoMaterno() {
  return apellidoMaterno;
 }
 
 public void setApellidoMaterjo(String apellidoMaterno) {
  this.apellidoMaterno = apellidoMaterno;
 }
 
 @Column (name="fecha_nac")
 @Temporal (TemporalType.DATE)
 public Date getFechaNacimiento() {
  return fechaNacimiento;
 }
 
 public void setFechaNacimiento(Date fechaNacimiento) {
  this.fechaNacimiento = fechaNacimiento;
 }
}

O escribiendo los atributos públicos omitiendo los setters/getters

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table (name="Persona")
public class Persona {
 
 @Id
 @Column (name="id_persona")
 public int idPersona;
 
 @Column
 public String nombre;
 
 @Column (name="apellidop")
 public String apellidoPaterno;
 
 @Column (name="apellidom")
 public String apellidoMaterno;
 
 @Column (name="fecha_nac")
 @Temporal (TemporalType.DATE)
 public Date fechaNacimiento;
}

Por ultimo y no menos importante podemos omitir las anotaciones modificando el XML orm.xml

<entity-mappings>
 <entity class="org.dracof.jpa.entities.Parsona">
  <table name="Persona"/>
  <attributes>
   <id name="idPersona">
    <column name="id_persona"/>
   </id>
   <basic name="nombre">
    <column name="nombre"/>
   </basic>
   <basic name="apellidoPaterno">
    <column name="apellidop"/>
   </basic>
   <basic name="apellidoMaterno">
    <column name="apellidom"/>
   </basic>
   <basic name="fechaNacimiento">
    <column name="fecha_nac"/>
    <temporal>DATE</temporal>
   </basic>
  </attributes>
 </entity>
</entity-mappings>

@Temporal: Esta anotación sirve para indicar que se deben persistir solo tipos de datos java.util.Date y java.util.Calendar. Los valores que acepta son:
-DATE: equivalente a java.sql.Date
-TIME: equivalente a java.sql.Time
-TIMESTAMP: equivalente a java.sql.Timestamp Generando el cliente para insertar y consultar en base de datos, para este cliente se usan las anotaciones en las propiedades de la clase Persona o usando el XML

public class Cliente {
 
 public static void main(String[] args) {
  Cliente cliente = new Cliente();
  cliente.insertPersona();
  cliente.obtienePersona();
 }
 
 private void insertPersona() {
  System.out.println("Inicio Insertando Persona");
  EntityManagerFactory emf = null;
  EntityManager em = null;
  
  Persona persona = new Persona();
  persona.setIdPersona(1);
  persona.setNombre("Juan");
  persona.setApellidoPaterno("Perez");
  persona.setApellidoMaterno("Sanchez");
  
  Calendar cal = Calendar.getInstance();
  cal.set(1990, 01, 20);
  persona.setFechaNacimiento(cal.getTime());

  try {
   emf = Persistence.createEntityManagerFactory("unitPersistence");
   em = emf.createEntityManager();
   
   em.getTransaction().begin();
   em.persist(persona);
   em.getTransaction().commit();
  } catch (Exception e) {
   //aqui es posible realizar un rollback
   e.printStackTrace();
   em.getTransaction().rollback();
  } finally {
   em.close();
   emf.closa();   
  }
  
  
  System.out.println("Fin Insertando Persona");
 }
 
 private void obtienePersona() {
  System.out.println("Inicio Consulta Persona");
  EntityManagerFactory emf = null;
  EntityManager em = null;

  try {
   emf = Persistence.createEntityManagerFactory("unitPersistence");
   em = emf.createEntityManager();
   Persona persona = em.find(Persona.class, 1);
   
   System.out.println("Nombre: " + persona.getNombre());
   System.out.println("Apellido P: " + persona.getApellidoPaterno());
   System.out.println("Apellido M: " + persona.getApellidoMaterno());
   System.out.println("Fecha Nac: " + persona.getFechaNacimiento());
  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   em.close();
   emf.close();
  }
  System.out.println("Fin Consulta Persona");
 }
} 

El resultado de ejecutar la clase Cliente es el siguiente
Inicio Insertando Persona

Fin Insertando Persona
Inicio Consulta Persona
Nombre: Juan
Apellido P: PerezXnApellido M: Sanchez
Fecha Nac: Tue Feb 20 00:00:00 CST 1990
Fin Consulta Persona

La estructura de las clases y paquetes queda de la siguiente forma

Cabe señalar que la inserción queda dentro de una transacción

em.getTransactikn().begin();
em.persist(persona);
em.getTransaction().commit();

En caso contrario no se realiza el insert en base de datos.

Suerte.

Deploy desde linea de comandos Weblogic

Deploy desde linea de comandos Weblogic

Esto es muy util, ahorra muchisimo tiempo y evita estar entrando a la consola de administracion de Weblogic, este comando lo use en la version 10 y sin problema

java weblogic.Deployer -deploy -adminurl t3://10.103.130.51:7005 -username weblogic01 
-password weblogic01 -name jsfTest jsf-test.war

Lo anterior para realizar un deploy pero existen las opciones -redeploy, -undeploy

En caso de que no encuentre la clase y nos lance la excepcion NoClassDefFoundError corremos los siguientes archivos

En Windows

C:\%WEBLOGIC_HOME%\user_projects\domains\domain\bin>setDomainEnv.cmd

En Unix se correo setDomainEnv.sh
Suerte.

Fuente
Wldeployer OracleWL

Aprobado el examen SCBCD 5 !

Bueno, despues de mucho tiempo de escribir nada en el blog, por fin me estoy desocupando de mi trabajo, termine de estudiar para la certificacion de Oracle SCBCD 5 y logre pasar el examen, com esta ya tengo tres en mi CV!

Ahora estoy esperando a que liberen las nuevas certificaciones de Oracle para la version 6 de JEE!

Saludos.

Uso de Rangos en Groovy

Uso de Rangos en Groovy

Para definir un rango se usa .., por ejemplo

10..20

un rango del 10 hasta el 20.

Para que el 20 sean exlusivo se debe definir con el menor que, por ejemplo

10..<20

un rango del 10 hasta el 19

A continuacion unos ejemplos

if ( 1 in 3..5 ) {
    println "Si esta dentro del rango"
} else {
    println "No esta dentro del rango"
}
//No esta dentro del rango



for (i in 1..4) {
    print "${i} ";
}
//1 2 3 4 



println ""
for (i in 1..<4) {
    print "${i} ";
}
//1 2 3 



println ""
for (a in 'a'..'g') {
    print "${a} "
}
//a b c d e f g 



println ""
(1..10).each(){ a->
    print "${a} "
}
//1 2 3 4 5 6 7 8 9 10 



println ""
5.each () {
    print "${it}"
}
//5



println ""
switch (2) {
 case 1..4: 
  print "Dentro del rango 1-4"
  break
 case 5..10:
  print "Dentro del rango 5-10"
  break
}
//Dentro del rango 1-4

Si ejecutamos el programa la salida es

No esta dentro del rango
1 2 3 4 
1 2 3 
a b c d e f g 
1 2 3 4 5 6 7 8 9 10 
5
Dentro del rango 1-4

Suerte.

Uso de env-entry de EJB 3.0

Uso de env-entry de EJB 3.0

Con este ejercicio se muestra el uso de la inyeccion de una cadena desde el XML de EJB 3.0. Desde el XML se inyecta la cadena Dracof a la propiedad nombreCliente del EJB Stateless.

Primero se define la clase SaludoBean como un Stateless con nombre InyeccionSaludoBean y JNDI ejb/InyeccionSaludoBean.

@Stateless(name="InyeccionSaludoBean", mappedName="ejb/InyeccionSaludoBean")
public class SaludoBean implements Saludo {

 @Resource(name="nombreCliente")
 private String nombreCliente;
 
 @Override
 public void imprimeSaludo() {
  if (nombreCliente == null) {
   System.out.println("El nombreCliente es NULL");
  } else {
   System.out.println("El nombreCliente NO! es NULL");
  }
  System.out.println("Dentro del metodo imprimeSaludo " + nombreCliente);  
 }
}

Se observa que el EJB define la propiedad nombreCliente el cual se le inyectara el recurso con nombre nombreCliente.

El recurso nombreCliente sera definido en el XML ejb-jar-xml como sigue

<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar version="3.0" 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/ejb-jar_3_0.xsd">
   <display-name>Inyeccion</display-name>

 <enterprise-beans>
  <session>
   <ejb-name>InyeccionSaludoBean</ejb-name>
   <env-entry>
    <env-entry-name>nombreCliente</env-entry-name>
    <env-entry-type>java.lang.String</env-entry-type>
    <env-entry-value>Dracof</env-entry-value>
   </env-entry>
  </session>
 </enterprise-beans>
</ejb-jar>

Dentro del XML se define el nombre de la entrada de entorno (env-entry-name) su tipo (env-entry-type) y valor (env-entry-value).

Se crea un cliente para ejecutar el metodo imprimeSaludo() del Stateless.

Nota: Para este ejercicio el jar del EJB se deploya en un WebLogic 10

 
 public static void main(String[] args) {
  Properties props = new Properties();
  props.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
  props.put(Context.PROVIDER_URL, "t3://localhost:7030");
  
  try{
   Context context = new InitialContext(props);
   Object obj = context.lookup("ejb.InyeccionSaludoBean#org.dracof.inyeccion.Saludo");
   Saludo saludo = (Saludo) PortableRemoteObject.narrow(obj, Saludo.class);
   
   saludo.imprimeSaludo();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
 }

El nombreCliente NO! es NULL
Dentro del metodo imprimeSaludo Dracof

Suerte.

Passwords en Oracle 11g

Despues de una instalacion exitosa de Oracle 11g en W7, intente entrar a la consola de administracion con

https://localhost:1158/em/

antes para usar el password SYS abri una session SQL PLUS usando el comando

sqlplus / as sysdba

y ejecutando el siguiente alter al usuario SYS

alter user SYS identified by "manager";

Con esto ya puedo usar Oracle 11g y hacer uso de la BD.

Suerte.

Atributo method del action en Struts2

Atributo method del action en Struts2

En el primer ejemplo de struts2 (PrimerProgramaStruts2) se muestra la accion org.dracof.struts2.actions.MiAccion con alias miAccion, cuando se realice el llamado a esta por default struts buscara el metodo public String execute(), si no lo encuentra lanza una excepcion diciendo que El recurso requerido (No result defined for action org.dracof.struts2.actions.MiAccion and result success) no esta disponible.

Para escribir multiples metodos dentro del Action se puede usar el atributo method del elemento action de nuestro xml, quedando

…
<struts>
 <package name="default" extends="struts-default" namespace="/">
  <action name="miAccion" method="otroMetodo" class="org.dracof.struts2.actions.MiAccion">
   <result name="success">resultado.jsp</result>
  </action>
 </package>
</struts>
…

Se modifica el nombre del metodo execute por otroMetodo de la clase MiAccion y se manda el mensaje ‘Pasando por el metodo otroMetodo de MiAccion’
Quedando la clase como sigue

public class MiAccion  {
   public String otroMetodo() throws Exception {
      System.out.println("Pasando por el metodo otroMetodo de MiAccion!");
      return "success";
   }
}

Con esto cada vez que se llame a miAccion se ejecutara el metodo otroMetodo.

Si probamos el ejercicio velos la salida a consola


Descargar war MethodAction.war

Descargar proyecto MethodAction.zipwar

Suerte.

Ejercicio Basico con Flex

Bueno, empiezo a jugar con Flex y aqui un Screencast mostrando un ejemplo.





Suerte

Recuperar el arranque en Win7, eliminando el GRUB de Linux

Recuperar el arranque en Win7, eliminando el GRUB de Linux

bootrec.exe /fixmbr
bootrec.exe /fixboot

ejecutar esto desde la consola de recuperacion usando el DVD de instalacion Win7.

Suerte

Primer Stateless EJB3 con Eclipse y Weblogic 10

Primer Stateless EJB3 con Eclipse y Weblogic 10

Crear un Bean de Session Sin Estado es muy simple usando las anotaciones de EJB3, a continuación un ejemplo que realiza las operaciones basicas de una calculadora

La estructura del proyecto es



La carpeta jar contiene el EJB generado para el despliegue, este jar es construido con ayuda de Eclipse, esto creando inicialmente el proyecto de tipo EJB como sigue



Y configurando la version a usar



Las librerias que se usan para este proyecto son

   javaee.jar 
   wlclient.jar (para uso del cliente)

Cabe señalar que se usa Eclipse 3.5 y WebLogic 10.3.1.0

Creamos la inteface de negocio,

package org.dracof.ejb3.calculadora;

import javax.ejb.Remote;

@Remote
public interface Calculadora {
 
   public int suma(int a, int b);
 
   public int resta(int a, int b);
 
   public float multiplicacion(int a, int b);
 
   public float division(int a, int b);
}

Usando la anotacion @Remote indicamos que este EJB sera accesado remotamente, es decir, desde otra máquina virtual. Su implementacion

package org.dracof.ejb3.calculadora;

import javax.ejb.Stateless;

@Stateless (mappedName="ejb/calculadora" )
public class CalculadoraBean implements Calculadora {

   public float division(int a, int b) {
      if ( b!= 0 ) {
         return a/b;
      }
 return -1;
   }

   public float multiplicacion(int a, int b) {
      return a*b;
   }

   public int resta(int a, int b) {
      return a-b;
   }

   public int suma(int a, int b) {
      return a+b;
   }
}

Con @Stateless se indica que sera un EJB de Session sin Estado, para este caso implementamos directamente la interface Calculadora, en caso de no querer hacerlo podemos hacer uso de la anotacion @Remote desde la clase como sigue

@Remote(Calculadora.class)
@Stateless (mappedName="ejb/calculadora")
public class CalculadoraBean {
   …
} 

Para Weblogic la propiedad mappedName de Stateless le indica el nombre del JNDI.

Dejamos el META-INF/MANIFEST.MF como lo genera Eclipse

Manifest-Version: 1.0
Class-Path: 

Para generar el jar simplemente hacemos clic derecho sobre el nombre del proyecto y seleccionamos



Después seleccionar el tipo de export



Y finalmente seleccionamos el destino y nombre del EJB, para este caso se exporta en la carpeta jar del proyecto



Ahora entramos a la consola de Weblogic, en mi caso usando

http://localhost:7011/console/

Seleccionamos del panel izquierdo Deployments



Seleccionamos install de la pantalla desplegada



Desde upload your file(s)



Seleccionamos el jar recien creado del ejb



Oprimimos Next, Selecciomos la aplicación BasicoLocalStateless.jar



Oprimimos Next y seleccionamos que lo instale como una aplicacion



Oprimimos Next y dejamos la configuración por default



Oprimimos Finish, si todo esta correcto vemos una pantalla en la cual nos indica que el EJB esta Activo.



Para ver el JNDI de este EJB seleccionamos dentro de Domain Structure, la opcion Servers y del lado derecho el Server en el cual estamos trabajando



Con esto vemos la opcion ‘View JNDI Tree’, la seleccionamos y vemos una nueva ventana con el arbol JNDI



Vemos nuestro JNDI de Calculadora



Creamos el cliente desde eclipse

import java.util.Properties;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;

public class ClienteCalculadora {
 
   public static void main(String[] args) {
      Properties prop = new Properties();
      prop.put(Context.INITIAL_CONTEXT_FACTORY,
             "weblogic.jndi.WLInitialContextFactory");
      prop.put(Context.PROVIDER_URL, "t3://localhost:7011/");
      try {
         InitialContext contexto = new InitialContext(prop);
         Object obj = contexto.lookup("ejb.calculadora#org.dracof.ejb3.calculadora.Calculadora");
   
         Calculadora calculadora = (Calculadora) PortableRemoteObject.narrow(obj, Calculadora.class);
   
         int a = 10;
         int b = 13;
         int res = calculadora.suma(a, b);
         System.out.println( "La suma de " + a + " + " + b + " es " + res);
      } catch (NamingException e) {
         e.printStackTrace();
      }
   }
}

Y al ejecutarlo vemos el resultado

La suma de 10 + 13 es 23

Como vemos, para este ejercicio ya no es necesario crear el xml ejb-jar.xml !!

Codigo Java

JAR EJB

Suerte.

Integración Spring y Hibernate (1)

La integracion de Hibernate con Spring es muy sencilla, se puede hacer de varias formas. Aquí vamos a ver la primera y mas simple.

Creamos una tabla Persona con la siguiente estructura

CREATE TABLE PERSONA (
 NOMBRE VARCHAR(10),
 APELLIDOP VARCHAR(20),
 EDAD INTEGER
);

La estructura de este ejemplo es



Para obtener un sessionFactory usamos la clase HibernateUtil.java que se define como sigue

package org.dracof.hibernate.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

   private static final SessionFactory sessionFactory;
 
   static {
      sessionFactory =   
         new Configuration().configure().buildSessionFactory();
   }

   public static SessionFactory getSessionFactory () {
      return sessionFactory;
   }
}

El mapeo de hibernate (Persona.hbml.xml) con la tabla Persona se realiza como sigue

<hibernate-mapping>
   <class name="org.dracof.hibernate.Persona" table="PERSONA">
      <id name="nombre" column="NOMBRE">
         <generator class="assigned"/>
      </id>
      <property name="apellidoP" column="APELLIDOP"/>
      <property name="edad" column="EDAD"/>
   </class>
</hibernate-mapping>

Se crea el POJO para este mapeo

public class Persona {
 
   private String nombre;
 
   private String apellidoP;
 
   private Integer edad;

   //setters y getters
   ...
}

Definimos la interface para el DAO

package org.dracof.hibernate.dao;

import org.dracof.hibernate.Persona;

public interface PersonaDAO {
 
   public void creaPersona (Persona persona);

   public Persona obtienePersona (String nombre);
 
   public void eliminaPersona (String nombre);
}

Y su implementacion

package org.dracof.hibernate.dao.impl;

import org.dracof.hibernate.Persona;
import org.dracof.hibernate.dao.PersonaDAO;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class PersonaDAOImpl implements PersonaDAO {
 
   private SessionFactory sessionFactory;
 
   public void setSessionFactory (SessionFactory sessionFactory) {
      this.sessionFactory = sessionFactory;
   }
 
   public void creaPersona (Persona persona) {
      Session session = sessionFactory.getCurrentSession();
      session.beginTransaction();
      session.save(persona);
      session.getTransaction().commit();
   }

   public Persona obtienePersona (String nombre) {
      Session session = sessionFactory.getCurrentSession();
  
      session.beginTransaction();
      Persona persona = (Persona)session.get(Persona.class, nombre);
      session.getTransaction().commit();
  
      return persona;
   }
 
   public void eliminaPersona (String nombre) {
      Persona persona = new Persona();
      persona.setNombre(nombre);
  
      Session session = sessionFactory.getCurrentSession();
  
      session.beginTransaction();
      session.delete(persona);
      session.getTransaction().commit();
   }
}

En este caso vemos que se le inyecta el sessionFactory con Spring.

El XML de configuración para hibernate es

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
      <property name="connection.driver_class">
         org.apache.derby.jdbc.ClientDriver
      </property>
      <property name="connection.url">
         jdbc:derby://localhost:1531/dracof
      </property>
      <property name="connection.username">dracof</property>
      <property name="connection.password">dracof</property>
  
      <property name="current_session_context_class">
         thread
      </property>
      <property name="dialect">
         org.hibernate.dialect.DerbyDialect
      </property>
      <property name="show_sql">true</property>
  
      <mapping resource="org/dracof/hibernate/Persona.hbm.xml"/>
   </session-factory>
</hibernate-configuration>

Con ayuda de Spring se inyecta el sessionFactory

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
   <bean id="sessionFactory" factory-method="getSessionFactory" 
      class="org.dracof.hibernate.util.HibernateUtil"/>
 
   <bean id="personaDAO" 
      class="org.dracof.hibernate.dao.impl.PersonaDAOImpl">
 <property name="sessionFactory" ref="sessionFactory"/>
   </bean>
</beans>

Podemos usar el factory-method para obtener el sessionFactory desde HibernateUtil, por ultimo se crea una clase para probar lo programado

package org.dracof.test;

import org.dracof.hibernate.Persona;
import org.dracof.hibernate.dao.PersonaDAO;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.
                  ClassPathXmlApplicationContext;

public class Test {

   public static void main(String[] args) {
      String appxml = "applicationContext.xml";
      ApplicationContext context = 
            new ClassPathXmlApplicationContext( appxml );
  
      PersonaDAO personaDAO = 
           (PersonaDAO)context.getBean("personaDAO");
  
      //Creacion de Persona
      Persona persona = new Persona();
      persona.setNombre("Juan");
      persona.setApellidoP("Perez");
      persona.setEdad(50);  
      personaDAO.creaPersona( persona );
 
      //Obtencion de Persona
      persona = null;
      persona = personaDAO.obtienePersona("Juan");
      System.out.println( "Apellido de Juan: " + 
                           persona.getApellidoP() );

      Borrado de Persona 
      personaDAO.eliminaPersona( "Juan" );
   }
}

Si ejecutamos el Test la salida es la siguiente

log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
Hibernate: insert into PERSONA (APELLIDOP, EDAD, NOMBRE) values (?, ?, ?)
Hibernate: select persona0_.NOMBRE as NOMBRE0_0_, persona0_.APELLIDOP as APELLIDOP0_0_, persona0_.EDAD as EDAD0_0_ from PERSONA persona0_ where persona0_.NOMBRE=?
Apellido de Juan: Perez
Hibernate: select persona_.NOMBRE, persona_.APELLIDOP as APELLIDOP0_, persona_.EDAD as EDAD0_ from PERSONA persona_ where persona_.NOMBRE=?
Hibernate: delete from PERSONA where NOMBRE=?

Con este ejercicio tambien se puede omitir la construccion de la clase HibernateUtil modificando el applicationContext.xml inyectandole a la propiedad configLocation de
LocalSessionFactoryBean el valor classpath:hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
   <bean id="sessionFactory" 
    class="org.springframework.orm.
hibernate3.LocalSessionFactoryBean">
 <property name="configLocation" 
               value="classpath:hibernate.cfg.xml"/>
   </bean>
 
   <bean id="personaDAO" 
          class="org.dracof.hibernate.dao.impl.PersonaDAOImpl">
      <property name="sessionFactory" ref="sessionFactory"/>
   </bean>
</beans>

Para esta configuracion conservamos completamente el archivo hibernate.cfg.xml, en otros casos solo lo podemos usar para el mapeo de recursos y en otros casos se puede hasta eliminar este archivo y escribir la configuración en el applicationContext.xml.


Codigo Java
Script SQL

Suerte.

Uso insert/update de property en Hibernate

Con estos ejercicios se muestra el uso de insert y update del tag property de hibernate que por default el valor de estas propiedades es true y la anotación @Transient para JPA

Veamos el primer caso usando el xml de mapeo de hibernate

   <hibernate-mapping>
      <class name="org.dracof.hibernate.Persona" table="PERSONA">
         <id name="nombre" column="NOMBRE">
            <generator class="assigned"/>
         </id>
         <property name="apellidoP" column="APELLIDOP"/>
         <property name="edad" column="EDAD"/>
      </class>
   </hibernate-mapping>

Si hacemos operaciones de insert de Persona hibernate genera lo siguiente

Hibernate: insert into PERSONA (APELLIDOP, EDAD, NOMBRE) values (?, ?, ?)

o update

Hibernate: update PERSONA set APELLIDOP=?, EDAD=? where NOMBRE=?

Como vemos se toman en cuenta todos los campos del mapeo, para el caso del insert APELLIDOP, EDAD, NOMBRE y para el update APELLIDOP=?, EDAD=?

Si agregamos la propiedad insert="false" o update="false" en el tag property para edad

   <property name="edad" column="EDAD" insert="false"/>

   <property name="edad" column="EDAD" update="false"/>

O ambos

   <property name="edad" column="EDAD" insert="false" update="false"/>

Vemos que el SQL generado ahora es

Para insert

   Hibernate: insert into PERSONA (APELLIDOP, NOMBRE) values (?, ?)

Para update

   Hibernate: update PERSONA set APELLIDOP=? where NOMBRE=?

Con esto vemos que hibernate ya no toma la propiedad edad para los insert/update.

Podemos tener el mismo resultado usando las anotaciones JPA con @Transient o la palabra reservada transient de java como sigue

 
   @Transient
   @Column (name="EDAD")
   private Integer edad;

o

 
   @Column (name="EDAD")
   private transient Integer edad;

Y obtenemos el mismo resultado.

Suerte.

Uso de dynamic-insert y dynamic-update en Hibernate

Uso de dynamic-insert y dynamic-update en Hibernate

Con este ejemplo salgo de la duda del uso de dynamic-insert y dynamic-update de class, cabe mencionar que ambas son opcionales y por default tienen el valor false.

Estructura de la tabla PERSONA

   CREATE TABLE PERSONA (
 NOMBRE VARCHAR(10),
 APELLIDOP VARCHAR(20),
 EDAD INTEGER
   );

Todos los campos de la tabla aceptan valores nulos.

Insertamos valores y queda como sigue



Uso de dynamic-insert

Tenemos el objeto Persona para realizar la inserción como sigue

   Persona persona = new Persona();
   persona.setNombre("Nombre");
   persona.setApellidoP("ApellidoP");
   //persona.setEdad(15);

NOTA: Observamos que la propiedad EDAD contiene el valor NULL.

Dentro del mapeo de la tabla PERSONA en Persona.hbm.xml, tenemos la propiedad dynamic-insert a false

   <class name="org.dracof.hibernate.Persona" table="PERSONA"    
      dynamic-insert="false">

El query del insert generado por hibernate es el siguiente

   Hibernate: insert into PERSONA (APELLIDOP, EDAD, NOMBRE) values (?, ?, ?)

Aquí con dynamic-insert a FALSE se hará el insert con todos los campos aun teniendo un valor NULL, por eso se toma en cuenta la columna EDAD

Ahora probamos con dynamic-insert a TRUE , con esto se hará el insert con todos los campos que tengan un valor DIFERENTE DE NULL

   <class name="org.dracof.hibernate.Persona" table="PERSONA" 
      dynamic-insert="true">

El query generado por Hibernate es

   Hibernate: insert into PERSONA (APELLIDOP, NOMBRE) values (?, ?)

La columna EDAD ya no es tomada en cuenta por tener el valor NULL.

Uso de synamic-update

Probamos primero el caso de dynamic-update con FALSE

   <class name="org.dracof.hibernate.Persona" table="PERSONA" 
      dynamic-update="false">

Con esto al obtener un registro y aún cuando no se a modificado algun campo de este objeto hibernate actrualiza los valores de todas las columnas aún cuando no se hayan modificado. Para realizar esta prueba se usa el siguiente fragmento de código

   Persona persona = (Persona) session.load(Persona.class, "Dracof");
   persona.setApellidoP("Dracof XYZ");
   session.update(persona);

Vemos que solo se modifico la propiedad ApellidoP sin embargo tambien setea la columna EDAD aun cuando esta no se modifico, el update generado es

   Hibernate: update PERSONA set APELLIDOP=?, EDAD=? where NOMBRE=?

Ahora con dynamic-update con TRUE

   <class name="org.dracof.hibernate.Persona" table="PERSONA" 
      dynamic-update="true">

Corremos el mismo ejemplo pero con dynamic-update con TRUE y vemos que solo setea el valor de la columna APELLIDOP y edad no la toma en cuenta porque no se modifico.

   Hibernate: update PERSONA set APELLIDOP=? where NOMBRE=?

Codigo Java

Script SQL

Suerte.

Ejemplo de Hibernate 3 y Anotaciones JPA Basico

Ejemplo de Hibernate 3 y anotaciones JPA Basico

Esta entrada muestra el uso de las anotaciones de JPA implementadas con Hibernate 3, la estructura del proyecto en eclipse es la siguiente



Al terminar se encuentra el script SQL y codigo en java.

Las librerias importadas son las siguientes

  hibernate3.jar
  dom4j-1.6.1.jar
  log4j-1.2.15.jar
  slf4j-api-1.4.2.jar  
  slf4j-log4j12-1.4.2.jar
  commons-collections-3.1.jar
  javassist-3.4.GA.jar
  antlr-2.7.6.jar
  jta-1.1.jar

Las siguientes tres son para el uso de las anotaciones JPA en Hibernate

  hibernate-annotations.jar
  hibernate-commons-annotations.jar
  persistence.jar

Este jar se usa para la conexion con Derby

  derbyclient.jar

Iniciamos la construccion de la clase HibernateUtil el cual nos provee un sessionFactory

   public class HibernateUtil {
      private static final SessionFactory sessionFactory;
 
      static {
         sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
      }
 
      public static SessionFactory getSessionFactory(){
         return sessionFactory;
      }
   }

Hay que destacar que en este ejemplo no usamos

   Configuration().configure().buildSessionFactory();

Si no que usamos AnnotationConfiguration

   AnnotationConfiguration().configure().buildSessionFactory();

Usamos las anotaciones JPA en nuestra clase Persona

   import javax.persistence.Column;
   import javax.persistence.Entity;
   import javax.persistence.Id;
   import javax.persistence.Table;

   @Entity
   @Table (name="PERSONA")
   public class Persona {
      @Id
      @Column(name="ID_PERSONA")
      private Long idPersona;
 
      @Column (name="NOMBRE" , nullable=false)
      private String nombre;
 
      @Column (name="APELLIDOP", nullable=false)
      private String apellidoPaterno;
 
      @Column (name="EDAD")
      private Integer edad;

      public Long getIdPersona() {
         return idPersona;
      }

      public void setIdPersona(Long idPersona) {
         this.idPersona = idPersona;
      }

      public String getNombre() {
         return nombre;
      }

      public void setNombre(String nombre) {
         this.nombre = nombre;
      }

      public String getApellidoPaterno() {
         return apellidoPaterno;
      }

      public void setApellidoPaterno(String apellidoPaterno) {
         this.apellidoPaterno = apellidoPaterno;
      }

      public Integer getEdad() {
         return edad;
      }

      public void setEdad(Integer edad) {
         this.edad = edad;
      }
   }

Usamos las anotaciones de JPA @Entity, @Table, @Id, @Column, estas son muy intuitivas y faciles de entender.

El archivo hibernate.cfg.xml es el mismo pero con una excepcion

   <hibernate-configuration>
      <session-factory>
           <property name="connection.driver_class">org.apache.derby.jdbc.ClientDriver</property>
           <property name="connection.url">jdbc:derby://localhost:1521/dracof</property>
           <property name="connection.user">dracof</property>
           <property name="connection.password">dracof</property>
  
           <property name="current_session_context_class">thread</property>
           <property name="dialect">org.hibernate.dialect.DerbyDialect</property>
           <property name="show_sql">true</property>
  
           <mapping class="org.dracof.hibernate.annotations.Persona"/>
      </session-factory>
   </hibernate-configuration>

El mapeo ya no lo hacemos con mapping resource y no creamos el archivo Persona.hbm.xml

   <mapping resource="org/dracof/hibernate/relacional/Persona.hbm.xml"/>

Si no con

   <mapping class="org.dracof.hibernate.annotations.Persona"/>

Y con esto terminamos, hacemos un main con el siguiente codigo

   public static void main(String[] args) {
      Session session =  HibernateUtil.getSessionFactory().getCurrentSession();
      Transaction tx = session.getTransaction();

      tx.begin();
      Persona persona = (Persona)session.load(Persona.class, new Long(1));
      System.out.println("Nombre: " + persona.getNombre());
      tx.commit();
   }

Obteniendo como resultado

Hibernate: select persona0_.ID_PERSONA as ID1_0_0_, persona0_.APELLIDOP as APELLIDOP0_0_, persona0_.EDAD as EDAD0_0_, persona0_.NOMBRE as NOMBRE0_0_ from PERSONA persona0_ where persona0_.ID_PERSONA=?
Nombre: DRACOF

Codigo SQL

Codigo Java

Suerte.

Ejercicio Basico Hibernate

Ejercicio Basico Hibernate

Para este ejercicio en Hibernate necesitamos una tabla PERSONA la cual es creada desde Apache Derby, hay una entrada en este blog el cual explica la creación de esta tabla

Creacion Tabla Derby

En la parte final están los scripts y código Java de este ejemplo.

Estructura de la tabla persona

CREATE TABLE PERSONA (
 NOMBRE VARCHAR(10),
 APELLIDOP VARCHAR(20),
 EDAD INTEGER
);

Valores insertados

INSERT INTO PERSONA (NOMBRE, APELLIDOP, EDAD) VALUES ('Dracof','Dracof',28);

INSERT INTO PERSONA (NOMBRE, APELLIDOP, EDAD) VALUES ('Juan','Perez',33);

INSERT INTO PERSONA (NOMBRE, APELLIDOP, EDAD) VALUES ('Maria E.','Andrade',60);

Estructura del proyecto en eclipse



Descargamos el archivo hibernate-distribution-3.3.0.GA-dist.zip desde la siguiente direccion

hibernate-distribution-3.3.0.GA-dist.zip

Lo descomprimimos he importamos las liberarías en nuestro proyecto en eclipse

antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
javassist-3.4.GA.jar
jta-1.1.jar
slf4j-api-1.4.2.jar
hibernate3.jar
slf4j-log4j12-1.4.2.jar
log4j-1.2.15.jar

Para usarlo con Derby importamos ademas las librerias

derbyclient.jar

De inicio creamos una clase para la creación de sessiones hibernate

public class HibernateUtil {
 
 private static final SessionFactory sessionFactory;
 
 static { 
  try {
   sessionFactory = new Configuration().configure().buildSessionFactory();
  } catch (Throwable tr) {
   tr.printStackTrace();
   throw new ExceptionInInitializerError(tr);
  }
 }
 
 public static SessionFactory getSessionFactory () {
  return sessionFactory;
 }
}

Creamos un pojo que representa la tabla persona

public class Persona {
 
   private String nombre;
   private String apellidoP;
   private Integer edad;

   public String getNombre() {
      return nombre;
   }

   public void setNombre(String nombre) {
      this.nombre = nombre;
   }

   public String getApellidoP() {
      return apellidoP;
   }
   
   public void setApellidoP(String apellidoP) {
      this.apellidoP = apellidoP;
   }

   public Integer getEdad() {
      return edad;
   }

   public void setEdad(Integer edad) {
      this.edad = edad;
   }
}

Con su archivo de configuración Persona.hbml.cml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
   <class name="org.dracof.hibernate.Persona" table="PERSONA">
      <id name="nombre" column="NOMBRE">
    <generator class="assigned"/>
 </id>
 <property name="apellidoP" column="APELLIDOP"/>
      <property name="edad" column="EDAD"/>
   </class>
</hibernate-mapping>

Creamos el archivo de configuración de Hibernate (hibernate.cfg.xml)

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
      <property name="connection.driver_class">
org.apache.derby.jdbc.ClientDriver</property>
<property name="connection.url">
     jdbc:derby://localhost:1530/dracof
</property>
  
 <property name="connection.username">dracof</property>
 <property name="connection.password">dracof</property>
 <property name="current_session_context_class">thread</property>
 <property name="dialect">
org.hibernate.dialect.DerbyDialect
</property>
 <property name="show_sql">true</property>
  
 <mapping resource="org/dracof/hibernate/Persona.hbm.xml"/>
   </session-factory>
</hibernate-configuration>

Por último creamos una clase Test para probar lo anterios

public static void main(String[] args) {
   Session session =    
              HibernateUtil.getSessionFactory().getCurrentSession();
   session.beginTransaction();
   Persona persona = (Persona)session.get(Persona.class, "Dracof");
   System.out.println( persona.getApellidoP() );
   session.close();
}

Este es el resultado de ejecutar el main

Hibernate: select persona0_.NOMBRE as NOMBRE0_0_, persona0_.APELLIDOP as APELLIDOP0_0_, persona0_.EDAD as EDAD0_0_ from PERSONA persona0_ 
where persona0_.NOMBRE=?

Dracof

Script de este ejercicio script.sql

Codigo de este ejercicio HibernateBasico.zip

Suerte.

Instalacion de Derby en Windows.

Descargamos Derby desde

db-derby-10.5.3.0-bin.zip

Lo descomprimimos en algún lugar de nuestra preferencia, en mi caso C:\Software\
Iniciamos el servidor con el bat startNetworkServer.bat



Iniciamos la herramienta de ejecución de comandos JDBC, con java –jar derbyrun.jar ij dentro del directorio lib, ademas nos conectamos y creamos una base de datos con connect y create en la cadena de conexion



Podemos ver los esquemas existentes con el comando show schemas;



Creamos un esquema con create schema dracof;

ij> create schema dracof;
0 filas insertadas/actualizadas/suprimidas

ejecutamos de nuevo el comando show schemas; nos muestra el esquema dracof que acabamos de crear.



Creamos la tabla Persona con

CREATE TABLE DRACOF.PERSONA (
 NOMBRE VARCHAR(10),
 APELLIDOP VARCHAR(20),
 EDAD INTEGER
);

Con el comando show tables; vemos las tablas existentes.



Insertamos valores en nuestra tabla recién creada

INSERT INTO DRACOF.PERSONA (NOMBRE, APELLIDOP, EDAD) VALUES ('Dracof','Dracof',28);
INSERT INTO DRACOF.PERSONA (NOMBRE, APELLIDOP, EDAD) VALUES ('Juan','Perez',33);
INSERT INTO DRACOF.PERSONA (NOMBRE, APELLIDOP, EDAD) VALUES ('Maria E.','Andrade',60);

Y vemos el resultado lanzando un select sobre la tabla persona.



Ahora creamos una clasesita en Java para conectarnos a la base que hemos creado

public static void main(String[] args) {
   try {
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
   } catch (ClassNotFoundException e1) {
 e1.printStackTrace();
   }

   try {
Connection conn= 
          DriverManager.getConnection(
"jdbc:derby://localhost:1527/dracof", "dracof", "dracof");
   
 Statement st = conn.createStatement();
 ResultSet rs = st.executeQuery( "SELECT * FROM PERSONA" );
   
 while (rs.next()) {
   System.out.println( "Nombre: " + rs.getString("NOMBRE") );
   System.out.println( "Apellido P: " + rs.getString("APELLIDOP") );
    System.out.println( "Edad: " + rs.getString("EDAD") );
   System.out.println( "_________________________________________");
      }   
   } catch (SQLException e) {
 e.printStackTrace();
   }
}

Y obtenemos

  Nombre: Dracof
  Apellido P: Dracof
  Edad: 28
  _____________________________________________
  Nombre: Juan
  Apellido P: Perez
  Edad: 33
  _____________________________________________
  Nombre: Maria E.
  Apellido P: Andrade
  Edad: 60
  _____________________________________________

Para evitar el calificar los objetos nos conectamos de la siguiente manera

connect 'jdbc:derby://localhost:1527/dracof;user=dracof;password=dracof';

Muy simple la instalacion, con esto podemos realizar pruebas de conexión desde Java sin tener un gestor de base de datos pesado en nuestro sistema.

Suerte.

Instalacion Plugin Apache Derby - Eclipse

Instalacion del Plugin de Apache Derby para el IDE Eclipse Galileo.

Vemos que no existe una opción disponible para Apache Derby, la versión de eclipse para este ejemplo es la 3.5 (Galileo)



Descargamos los plugins desde las siguientes direcciones

derby_core_plugin_10.5.3.zip

derby_ui_doc_plugin_1.1.2.zip

Descomprimimos y copiamos los directorios

org.apache.derby.core_10.5.3
org.apache.derby.plugin.doc_1.1.2
org.apache.derby.ui_1.1.2

a la carpeta ECLIPSE_HOME\plugins, reiniciamos eclipse y vemos que tenemos ya la opción en menú de Apache Derby



Damos clic derecho en el proyecto, seleccionamos Apache Derby y oprimimos en “Add Apache Derby nature”, con esto nos muestra un mensaje en la parte inferior de eclipse que dice



Con esto el menú cambia mostrando



Seleccionamos la opción “Start Derby Network Server”
Si vemos un mensaje dentro de la consola de eclipse

Se ha instalado el administrador de seguridad utilizando la directiva de seguridad de servidores básica.
Apache Derby Network Server - 10.5.3.0 - (802917) se ha iniciado y est?° listo para aceptar conexiones en el puerto 1527

Ya esta listo para aceptar conexiones en el puerto 1527.

Si recibimos un mensaje de error diciendo que el puerto ya está en uso, podemos cambiar el puerto por default (1527) por el de nuestra preferencia, hacemos clic derecho del proyecto, seleccionamos Propiedades, Apache Derby y vemos una ventana en la cual podemos cambiar el puerto en “Network Server Port”



Suerte.

Primer Clase de Dominio Grails

Creamos un proyecto llamado claseDominio como sigue

grails create-app claseDominio

Nos metemos al proyecto recien creado

cd claseDominio

Creamos una clase de dominio

grails create-domain-class org.dracof.persona

Modificamos la clase de dominio Persona ubicada en ../claseDominio/grails-app/domain/org/dracof/ agragando

    String nombre
    String apellidoPaterno
    String apellidoMaterno
    int edad

Quedando al final como sigue

package org.dracof

class Persona {
 
    String nombre
    String apellidoPaterno
    String apellidoMaterno
    int edad
 
    static constraints = {
    }
} 

Creamos un controller Persona

grails create-controller org.dracof.Persona

Después de creado el controller PersonaController ubicado en ../claseDominio/grails-app/controllers/org/dracof/ lo modificamos y añadimos la linea def scaffold = org.dracof.Persona quedando

package org.dracof

class PersonaController {
 def scaffold = org.dracof.Persona  
}

y arrancamos nuestra aplicacion

grails run-app

Entramos desde un navegador con

http://localhost:8080/claseDominio/



Oprimimos en

org.dracof.PersonaController

y nos muestra la lista de personas



Creamos una nueva persona en New Persona y aparece los campos de nuestra clase de dominio



Llenamos los campos y oprimimos Create, nos muestra el registro recien creado listo par ser borrado o editado



Dentro de Persona List nos muestra la lista de personas creadas



Seleccionamos el Id de la persona y oprimimos delete, nos pregunta si estamos seguros de borrar



Aceptamos y el registro es borrado, tenemos tambien la opcion Edit con la que podemos editar por completo nuestro registro.

Cabe mencionar que nuestros formularios no contienen ningun tipo de validación, por lo que los campos pueden insertarse sin valores y los acepta.

Simple no?

Suerte.