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.