sábado, 23 de enero de 2016

Conociendo JDBI

Usar JDBC implica el uso de clases y algunas configuraciones que nos permiten establecer conexión con bases de datos. Además tan solo necesitamos algún driver para cada tipo de bases (MySQL, Oracle, Sqlite, Firebird,etc.).

Sin embargo, hay cierta complejidad cuando necesitamos manejar gran cantidad de información. Los que han programado en Java saben lo molesto que puede ser el acceso a base de datos mediante los mecanismos que nos proporciona el JDBC (Java DataBase Connectivy).  No es que sean malos, pero cuando se trata de administrar la información de un  proyecto más o menos grande si causa algunos problemas.  

JDBI nace gracias a la necesidad de los programadores por acceder y administrar bases de datos de una manera más sencilla. Es una librería Java que promete ser una alternativa más adecuada al uso de JDBC.

JDBI nos ofrece dos estilos:

  1. Estilo fluido: Donde se hace uso de Datasource similares a JDBC, pero de una manera mucho más sencilla.
  2. Estilo Objetos SQL: Similar a lo que hacemos usando Hibernate o JPA nativo. donde tenemos nuestras "Entities" y las manipulamos mediante DAOs. 
 Más adelante haremos algunos ejemplos.

Links
http://jdbi.org/


jueves, 31 de diciembre de 2015

Scala ... en ejemplos sencillos no. 7 [Mapas]

Los mapas o "hashmap" en lenguajes como Scala, Java, etc. son colecciones de objetos desordenados. Se compone de una "llave o identificador" y su correspondiente valor.


Mapa mapa = Mapa ()

Objeto obj= Objeto()

Integer valor= Integer()

mapa.put(obj,valor)


Podemos obtener algo como esto:
mapa: {"uno":1,"dos":2,"tres":3}
mapa:{"A":3223,"Z":4329,"W":4322,"ACF":434}

En Scala podemos crear un mapa escribiendo:
var mapa: Map[String,Int] = Map()

Un mapa vacío que puede ser llenado de la siguiente manera:
mapa += (objLlave -> valor)

Tenemos así:  Mapas.scala


object Mapas{

   def main(args: Array[String]): Unit ={

       var mapa: Map[String,Int] = Map()

       mapa += ("uno" -> 1)

       mapa += ("tres" -> 3)

       mapa += ("Clave" -> 456)

   }

}


Para recorrer el mapa creado:

mapa.keys.foreach{ k =>

     Console.println("Llave:"+k)

     Console.println("Valor:"+mapa(k))

} 



sábado, 12 de diciembre de 2015

Groovy en ejemplos no.9: Leer un JSON

Usar archivos JSON para el intercambio de información entre aplicaciones se ha vuelto muy indispensable. Es una alternativa para sustituir el uso de archivos XML.

Un archivo JSON se compone de:
  • Una colección tipo diccionario con nombre y valor.
  • Un arreglo o lista ordenada.
Ejemplo. Un archivo JSON llamado "persona.json" puede tener una estructura similar a la siguiente:
{
   "persona": {
          "nombre": "Mariana",
           "edad": 32
   }
}

Donde "persona" es el nodo (objeto) principal. Los valores pueden ser de tipo boolean (true o false), númericos y cadenas.  También podemos definir arreglos (que inician y cierran con corchetes) como este:
{
   "persona": {
          "nombre": "Mariana",
           "edad": 32,
          "libros":[
           "El extraño caso de el perro en el ropero",
           "El error de llamarse Godofredo"
         ]
   }
}

Donde "libros" es el arreglo.

¿Cómo leer el archivo JSON?
  • Necesitamos crear un archivo json (que cumpla con la estructura adecuada), y que denominaremos como "persona.json"
  • Usar la librería groovy.json.JsonSlurper

leerJSON.groovy

import groovy.json.JsonSlurper
import java.io.File

static main(args) {
  def json=new JsonSlurper()
  def archivo=new File("persona.json")

  if(archivo.exists()){
    println "Archivo existe:${archivo.getAbsolutePath()}"
    def objeto=json.parse(archivo) 
    if(objeto !=null){
        if(objeto.persona.nombre == null && objeto.persona.nombre == null){
            println "Objetos nulos"
        }
        javax.swing.JOptionPane.showMessageDialog(null, "Nombre:"+objeto.persona.nombre+"\nEdad:"+objeto.persona.edad)
    }
  }

}


Para acceder a una propiedad del objeto es necesario definir su nombre, por ejemplo, si queremos obtener el "valor" de la propiedad "nombre" debemos acceder de este modo:  objeto.persona.nombre

Ejecutamos: groovy leerJSON.groovy

Y obtenemos:




Links
https://geekytheory.com/json-i-que-es-y-para-que-sirve-json/
http://www.json.org/json-es.html

sábado, 28 de noviembre de 2015

Javascript en ejemplos ... uso de document.getElementById().style

En esta ocasión crearemos un ejemplo para editar el estilo de un componente html.

Supongamos que tengo dos div de la siguiente manera:
<div id="miIdentificador1">
       <p>Este es el primer div</p>
</div>

<div id="miIdentificador2">
       <p>Este es el segundo div</p>
</div>


Ahora creo un archivo javascript y escribo una función:
function cambiaEstilo(){
      /* código */
}

Para acceder al componente div opto por crear un document y usar la función getElementById(), esta función nos permite acceder mediante su "identificador":

function cambiaEstilo(){
   document.getElementByd("miIdentificador1")
   document.getElementByd("miIdentificador2")
}

Ahora puedo usar la propiedad style para editar el estilo:

document.getElementById("miIdentificador1").style.backgroundColor="#ACD";document.getElementById("miIdentificador1"').style.color="#FF0040";document.getElementById("miIdentificador1").style.marginTop=".98in";
document.getElementById("miIdentificador1").style.fontFamily = "Impact"; document.getElementById("miIdentificador1").style.textAlign = "center";
document.getElementById("miIdentificador1").style.textIndent = "50px";

Para activar este script se puede usar un componente <button>

<button id="miBoton2" onclick="cambiaEstilo()">Cambiar estilo</button>




lunes, 16 de noviembre de 2015

HTML5 en ejemplos no.1


En un post anterior había escrito sobre HTML5, la estructura básica de un documento y algunas características. Además de algunos sitios de interés.

Este lenguaje de hipertexto (en su quinta versión) nos permite incluir etiquetas para incrustar imágenes "dinámicas", manipulación de audio y vídeo, entre otras cosas más.  Se considera el asesino de Flash (Adobe Flash), pues pretende que el desarrollador abandone esa tecnología.

Antes del auge de las apps, tablets, iphone, android, etc. Los programadores y diseñadores nos emocionaba(o aterraba) aprender a crear animaciones usando Flash (en ese entonces propiedad de Macromedia), el manejo de líneas de tiempo, fotogramas, efectos, etc. La llegada de HTML5 prácticamente acabo con la necesidad de usar esta tecnología. Depender de la instalación de plugins para reproducir archivos .swf era bastante tedioso para los usuarios (además de que algunos sitios se volvían muy "pesados" en cargar).

¿Qué encontraremos en HTML5?
La capacidad de crear y manipular gráficos, mejor manejo a formularios, mejorar el intercambio de información entre aplicaciones web (ej. metadatos), y conocer la ubicación del usuario. Entre otras cosas más.


1. En este ejemplo haremos uso de la API de Geolocalización. 

Creamos un archivo js llamado geolocalizar.js, escribimos:

/*las opciones*/
  var options = {
        enableHighAccuracy: true,
        timeout: 5000,
        maximumAge: 0
    };

/*método para mostrar errores*/
    function error(err) {
        console.warn('ERROR(' + err.code + '): ' + err.message);
    };


/*método que define la latitud y longitud del origen*/
    function origen(position){
        var latitud = position.coords.latitude;
        var longitud = position.coords.longitude;

    }
/*método para activar la golocalización

 recibe parámetros de opción,error y la posición del origen 
*/
    function activa_origen(){
        navigator.geolocation.getCurrentPosition(origen,error,options);
    }

 
Tenemos ahora una página con formato HTML5 , la llamaremos localiza.html:

<!DOCTYPE html>
 <html lang="es">
 <head>
  <meta charset="utf-8">
  <title>Mi primer página HTML5</title>

<script src="geolocalizar.js"></script>
</head>
<body>
<header><h1>Geolocalización</h1></header>
<section id="contenedor">
<article>
CodemonkeyJunior
</article>
<aside>


<!-- Aqui esta el botón que ejecuta el script -->
<button onclick="javascript:activa_origen();">Mostrar Posici&oacute;n</button>

 </aside>
<article></article>
</section>
<footer>@codemonkeyjunior</footer>
</body>
</hml>


Links
https://whatwg.org/
http://www.w3schools.com/
https://es.wikipedia.org/wiki/HTML5


sábado, 26 de septiembre de 2015

Groovy en ejemplos no. 8 ... convirtiendo un archivo groovy a javascript

En el post anterior vimos un ejemplo usando Grooscript, ahora veremos como convertir un archivo *.groovy a *.js.  Escribiremos tres archivos:
  • Philosopher.groovy
  • conversor.groovy
  • Philosopher.js
En el primero tendremos la clase Philosopher. El segundo servirápara convertir ese código a javascript. El tercero es donde se contendré el código javascript generado.


Philosopher.groovy
class Philosopher{
    String nombre
    int edad
}



conversor.groovy
@Grab('org.grooscript:grooscript:1.2.1')

import org.grooscript.GrooScript

GrooScript.convert('Philosopher.groovy', 'Philosopher.js')



Ejecutamos: groovy conversor.groovy

Philosopher.js
function Philosopher() {
  var gSobject = gs.inherit(gs.baseClass,'Philosopher');
  gSobject.clazz = { name: 'Philosopher', simpleName: 'Philosopher'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.nombre = null;
  gSobject.edad = null;
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
 
  return gSobject;
};


Es solo una forma de como convertir código groovy a javascript.

domingo, 20 de septiembre de 2015

Groovy en ejemplos no. 7 ... usando Grooscript


En esta ocasión usaremos Grooscript. Se trata de una herramienta para convertir código escrito en Groovy a Javascript.

GroovyToJavascript.groovy
//es necesario importar la librería grooscript.1.2.1
@Grab('org.grooscript:grooscript:1.2.1')

import org.grooscript.GrooScript


class Philosopher{
    String nombre
    int edad
}

def resultado = GrooScript.convert '''
    def kant = new Philosopher(nombre:"Immanuel Kant")
    kant.with{
        edad= 36
    }
'''

println resultado


Compilamos:
groovyc GroovyToJavascript.groovy

Ejecutamos:
groovy GroovyToJavascript.groovy

Nos imprimirá:
var kant = Philosopher(gs.map().add("nombre","Immanuel Kant"));
kant.withz(function(it) {
  return gs.sp(this, 'edad',36);
});


Podemos guardar el la salida en un archivo javascript:
groovy GroovyToJavascript.groovy > groovy.js


Para el siguiente post veremos más a fondo esta herramienta.



¿Qué lenguaje de programación debes aprender en un mundo con IA?

Las herramientas de IA están matando, literalmente, a la programación. Cualquiera con un Github Copilot, DeepSeek, Chat GPT, etc. pu...

Etiquetas

Archivo del blog