Code monkey: 2017

viernes, 9 de junio de 2017

Simple texto (Cómo deberíamos escribir nuestro código)

Recuerda que mudamos el blog:CodeMonkey Junior

¿Cómo deberíamos escribir nuestro código? en el siguiente vídeo se comparten algunas ideas que pueden servirnos a la hora de escribir nuestro código:

Recuerda, también puedes consultar el nuevo blog de Codemonkeyjunior

sábado, 27 de mayo de 2017

Nuevo blog de codemonkey junior

He aquí el nuevo blog:
https://codemonkeyjunior.wordpress.com/

He decidido trasladar el blog a otro sitio. Seguiré escribiendo algunos post.

Gracias.

miércoles, 10 de mayo de 2017

Construyendo proyectos con Gradle (estructura de directorios)

La estructura de todo proyecto en Gradle debe tener la siguiente forma:

Proyecto
     |
     src
      |
          main
          | java
                | resources

        | test
   | java
   | resources

Una parte de desarrollo:
src/main/java
src/main/resources

Y una de testing (pruebas):
src/test/java
src/test/resources

Dentro de la carpeta src/main/java debe estar nuestra clase principal.
Ejemplo:
src/main/java/Main.java

Además de la estructura debemos contar con el archivo build.gradle:
Proyecto
|
     src
      |
          main
          | java
                | resources

        | test
   | java
   | resources
    |
build.gradle

Es decir:
Proyecto
src/main/java/Main.java
src/main/resources
src/test/java/Main.java
src/test/resources
build.gradle

Dentro del archivo build.gradle escribiremos:

apply plugin: 'java'
apply plugin: 'application'

sourceCompatibility = 1.8

targetCompatibility = 1.8
mainClassName = "org.codemonkey.Main"
version = "1.0"


repositories {
    mavenLocal()
    mavenCenter()
}

dependencies {

    compile group: 'junit', name: 'junit', version: '4.12'

}

Ahora la clase Main.java

package org.codemonkey;

public class Main{
   
    public static void main(String[] args) throws IOException {
        System.out.println("Hola mundo!");
    }   
}

Dentro de la terminal teclearemos:
$gradle build

Con esto construiremos nuestro proyecto. Ahora listemos las tareas disponibles con:
$gradle task

Al desplegar las tareas debe haber una llamada run, esta nos permitira correr nuestro programa:
$gradle run

Salida:
Hola, mundo!

Con esto tendremos nuestro primer ejemplo. En el siguiente post veremos un ejemplo con Spring y Gradle.

domingo, 7 de mayo de 2017

Construyendo proyectos con Gradle (instalación con SDKMAN!)

Gradle es una herramienta que nos permite construir proyectos Java, Groovy, Scala, etc. de una manera más sencilla que usando Maven.

¿Cómo instalar Gradle?
La más sencilla es usando SDKMAN!, solo basta que escribas en la terminal:
$sdk install gradle

Así tendrás instalado la última versión, para comprobar que versión tienes instaladas tecleas:
$gradle --version o $gradle -v

Saldrá algo como esto:
------------------------------------------------------------
Gradle 3.5
------------------------------------------------------------

Build time:   2017-04-10 13:37:25 UTC
Revision:     b762622a185d59ce0cfc9cbc6ab5dd22469e18a6

Groovy:       2.4.10
Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
JVM:          1.8.0_131 (Oracle Corporation 25.131-b11)
OS:           Linux 4.4.0-75-generic amd64

Ahora nos ubicaremos en una carpeta y escribiremos un archivo llamado build.gradle. Dentro del archivo escribiremos lo siguiente:

task holaMundo << {
    println "Hola, mundo!"
}

Se trata de una simple tarea (task) denominada "holaMundo".

Para ejecutar el script escribiremos lo siguiente en la terminal:
$gradle -q build.gradle
$gradle -q holaMundo

Y obtendremos:
Hola, mundo!

Listo. Nuestro primer ejemplo esta hecho. En el siguiente post se verá la estructura de un proyecto Java usando Gradle .

Links:
https://gradle.org/
https://maven.apache.org/
http://codemonkeyjunior.blogspot.mx/search?q=maven
http://codemonkeyjunior.blogspot.mx/search?q=gradle

jueves, 13 de abril de 2017

JDBI con Groovy (3)

Siguiendo con el tema de JDBI está ocasión veremos una pequeña aplicación del tipo CRUD (altas, bajas, consultas y modificaciones).

Necesitamos crear una base de datos;

CREATE DATABASE test;

Una vez creada procedemos a seguir con estos pasos.

Crear un archivo *.sql llamado bien.sql para la creación de la tabla
Crear una BD en MySQL
Usar el archivo *.sql de la siguiente manera: $ mysql -u USUARIO -pCLAVE test < bien.sql
Crear un archivo froovy llamado Dao2.groovy
Importar las librerías necesarias para manipular datos y crear un log: jdbi, slf4j, y mysql mediante @Grapes
Crear una interface llamada BienDAO; esta interface contendrá los métodos con las declaraciones necesarias para la gestión de los datos
Crear una clase serializable llamada ModeloBien
Crear una clase que implemente la interface ResultSetMapper
Crear una clase principal (en este caso tendrá el mismo nombre del archivo)

bien.sql
CREATE TABLE IF NOT EXISTS bien(id int auto_increment primary key,numero int, usuario varchar(45), password varchar(32), maquina ENUM('pc','macosx','laptop_pc','laptop_macosx','movil'), sistema ENUM('windows','macosx','linux','android'), area ENUM('direccion','sistemas','soporte','hemeroteca','evaluacion','investigacion'), ip varchar(15), no_bien varchar(45));
INSERT INTO bien (numero, usuario, password, maquina, sistema, area, ip, no_bien) VALUES ('39','Yuri Gagarin','5432','pc','windows','sistemas','148.215.24.39','7749'),('36','Maria Petrovska','009GT2b','pc','linux','hemeroteca','148.215.24.36','7767'),('90','Tulio Alvarez','$36@L77','laptop_macosx','macosx','investigacion','172.215.22.25','4343');
UPDATE bien SET area='investigacion' WHERE id=2;
UPDATE bien SET area='soporte' WHERE id=1;
DELETE FROM bien WHERE id=3;
SELECT * FROM bien;

$ mysql -u TUUSUARIO -pTUCLAVE test < bien.sql

Esto nos permitirá cargar los datos contenidos en el archivo.

El programa consiste en un menú que te dará las opciones de insertar, consultar por id, consultar todos los registros, actualizar los datos por id y eliminar datos por id.

compilar: groovyc Dao2.groovy
ejecutar: groovy Dao2.groovy TUUSUARIO TUCLAVE

Ejemplo de uso y salida:
$ mysql -u root -p5432 test < bien.sql

$ groovyc Dao2.groovy

$groovy Dao2.groovy root 5432

[main] INFO jdbi - Iniciando script ...
[main] INFO jdbi - usuario: root
[main] INFO jdbi - password: 5432
    ******* Menu *******
1. Insertar datos
2. Consultar datos por id
3. Consultar total de datos
4. Actualizar datos por id
5. Eliminar datos por id
6. Salir
*******************************
Escoge una opción:2
    [Consulta por id]

Escribe el id:
2
    >> Id: 2
    >> Número: 36
    >> Usuario: Maria
    >> Password: 009GT2b
    >> Máquina: pc
    >> Sistema: linux
    >> Área: investigacion
    >> Ip: 148.215.24.36
    >> No_bien: 7767
    Búsqueda realizada
    ******* Menu *******
1. Insertar datos
2. Consultar datos por id
3. Consultar total de datos
4. Actualizar datos por id
5. Eliminar datos por id
6. Salir
*******************************
Escoge una opción:

Dao2.groovy

domingo, 9 de abril de 2017

JDBI con Groovy (2)

En esta ocasión veremos un ejemplo del uso de JDBI con Groovy.

Una clase principal llamada Dao.groovy
Una interface llamada MyDAO

MyDAO contendrá los método necesarios para crear una tabla, insertar valores, buscar un registro mediante su id y ,por último un método para cerrar.

El código viene de la página oficial de JDBI. Espero les sirva.

jueves, 5 de enero de 2017

JDBI con Groovy

En esta ocasión usaremos Groovy para crear una aplicación usando JDBI. Prácticamente es el mismo código usado la vez anterior que se dio un vistazo a JDBI. La diferencia radica en el uso de @Grapes y Grab para importar y cargar las librerías necesarias.

He aquí el código