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

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.

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.

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

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.

1. Crear un archivo *.sql llamado bien.sql para la creación de la tabla
2. Crear una BD en MySQL
3. Usar el archivo *.sql de la siguiente manera: $ mysql -u USUARIO -pCLAVE test  < bien.sql
4. Crear un archivo froovy llamado Dao2.groovy
5. Importar las librerías necesarias para manipular datos y crear un log: jdbi, slf4j, y mysql mediante @Grapes
6. Crear una interface llamada BienDAO; esta interface contendrá los métodos con las declaraciones necesarias para la gestión de los datos
7. Crear una clase serializable llamada ModeloBien
8. Crear una clase que implemente la interface ResultSetMapper
9. 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

	/**
	*@author Codemonkey Junior Blogspot
	*@description Uso de JDBI
	*/
	//compilación: groovy Dao2.groovy
	//ejecución: groovy Dao2.groovy rootMySQL clave
	@Grapes( [
	@Grab(group='org.slf4j', module='slf4j-api', version='1.7.25'),
	@Grab(group='org.slf4j', module='slf4j-simple', version='1.7.6'),
	@Grab(group='org.jdbi', module='jdbi', version='2.77'),
	@Grab(group='mysql', module='mysql-connector-java', version='5.1.26'),
	@GrabConfig(systemClassLoader=true)
	]
	)
	import java.sql.ResultSet;
	import java.sql.SQLException;
	import java.util.Scanner;
	import org.skife.jdbi.v2.sqlobject.Bind;
	import org.skife.jdbi.v2.sqlobject.SqlQuery;
	import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper;
	import org.skife.jdbi.v2.DBI;
	import org.skife.jdbi.v2.Handle;
	import org.skife.jdbi.v2.tweak.*;
	import org.skife.jdbi.v2.*;
	import org.skife.jdbi.v2.util.*;
	import org.skife.jdbi.v2.sqlobject.Bind;
	import org.skife.jdbi.v2.sqlobject.GetGeneratedKeys;
	import org.skife.jdbi.v2.sqlobject.SqlQuery;
	import org.skife.jdbi.v2.sqlobject.SqlUpdate;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	class Dao2{
	static main(args) {
	def log1 = LoggerFactory.getLogger('jdbi');
	log1.info 'Iniciando script ...'
	log1.info 'usuario: '+args[0]
	log1.info 'password: '+args[1]
	if(args.length > 0){
	for(;;){
	int opc= Integer.parseInt(menu())
	principal(opc, args[0], args[1])
	}
	}
	}
	static String menu(){
	String opc;
	println "\t******* Menu *******"
	println "1. Insertar datos"
	println "2. Consultar datos por id"
	println "3. Consultar total de datos"
	println "4. Actualizar datos por id"
	println "5. Eliminar datos por id"
	println "6. Salir"
	println "*******************************"
	opc=System.console().readLine 'Escoge una opción:'
	return opc;
	}
	static void principal(int opcion, String user, String passw){
	def id=0
	def numero=0
	def usuario=""
	def password=""
	def maquina=""
	def sistema=""
	def area=""
	def ip=""
	def no_bien=""
	def log2 = LoggerFactory.getLogger('jdbi');
	Scanner sc = new Scanner(System.in);
	DBI dbi = new DBI("jdbc:mysql://localhost:3306/test",user,passw);
	BienDAO dao= null;
	try {
	dao=dbi.open(BienDAO.class);
	switch(opcion) {
	case 1:
	println "\t[Inserción]\n"
	println "Número: "
	numero= sc.nextInt();
	usuario=System.console().readLine 'Usuario:'
	password=System.console().readLine 'Password:'
	maquina=System.console().readLine 'Máquina:'
	sistema=System.console().readLine 'Sistema:'
	area=System.console().readLine 'Área:'
	ip=System.console().readLine 'Ip:'
	no_bien=System.console().readLine 'No.bien:'
	dao.insertar(numero, usuario, password, maquina, sistema, area, ip, no_bien);
	println "\tInserción realizada"
	break;
	case 2:
	println "\t[Consulta por id]\n"
	println "Escribe el id: "
	id= sc.nextInt();
	println "\t>> Id: "+dao.encontrarPorId(id).id
	println "\t>> Número: "+dao.encontrarPorId(id).numero
	println "\t>> Usuario: "+dao.encontrarPorId(id).usuario
	println "\t>> Password: "+dao.encontrarPorId(id).password
	println "\t>> Máquina: "+dao.encontrarPorId(id).maquina
	println "\t>> Sistema: "+dao.encontrarPorId(id).sistema
	println "\t>> Área: "+dao.encontrarPorId(id).area
	println "\t>> Ip: "+dao.encontrarPorId(id).ip
	println "\t>> No_bien: "+dao.encontrarPorId(id).no_bien
	println "\tBúsqueda realizada"
	break;
	case 3:
	println "\t[Consulta total]\n"
	if(dao.verTodo().size() > 0){
	println "Lista de persona llena!!: "+dao.verTodo().size();
	for(int i=0 ; i < dao.verTodo().size(); i++){
	println "\t**Id:"+dao.verTodo().get(i).id;
	println "Número:"+dao.verTodo().get(i).numero;
	println "Usuario:"+dao.verTodo().get(i).usuario;
	println "Password:"+dao.verTodo().get(i).password;
	println "Máquina:"+dao.verTodo().get(i).maquina;
	println "Sistema:"+dao.verTodo().get(i).sistema;
	println "Área:"+dao.verTodo().get(i).area;
	println "Ip:"+dao.verTodo().get(i).ip;
	println "No.bien:"+dao.verTodo().get(i).no_bien;
	}
	}
	break;
	case 4:
	println "\t[Actualización por id]\n"
	println "Escribe el id: "
	id= sc.nextInt();
	println "Número: "
	numero= sc.nextInt();
	usuario=System.console().readLine 'Usuario:'
	password=System.console().readLine 'Password:'
	maquina=System.console().readLine 'Máquina:'
	sistema=System.console().readLine 'Sistema:'
	area=System.console().readLine 'Área:'
	ip=System.console().readLine 'Ip:'
	no_bien=System.console().readLine 'No.bien:'
	dao.modificarPorId(id, numero, usuario, password, maquina, sistema, area, ip, no_bien);
	println "\tActualización realizada"
	break;
	case 5:
	println "\t[Eliminación por id]\n"
	println "Escribe el id: "
	id= sc.nextInt();
	dao.eliminarPorId(id);
	println "\tEliminación realizada"
	break;
	case 6:
	println "\t[Adiós]\n"
	log2.info 'Cerrando conexión'
	dao.close();
	System.exit(0)
	break;
	default:
	println "\tEsa opción no existe"
	break;
	}
	}
	catch(Exception e) {
	log2.error 'Error: '+e.toString()
	}
	}
	}
	class ModeloBien implements java.io.Serializable{
	private static final long serialVersionUID=1L;
	int id
	int numero
	String usuario
	String password
	String maquina
	String sistema
	String area
	String ip
	String no_bien
	}
	class ModeloBienMapper implements ResultSetMapper<ModeloBien> {
	@Override
	public ModeloBien map(int arg0, ResultSet r, StatementContext arg2) throws SQLException {
	ModeloBien mbien=new ModeloBien();
	mbien.id=r.getInt("id")
	mbien.numero=r.getInt("numero")
	mbien.usuario=r.getString("usuario")
	mbien.password=r.getString("password")
	mbien.maquina=r.getString("maquina")
	mbien.sistema=r.getString("sistema")
	mbien.area=r.getString("area")
	mbien.ip=r.getString("ip")
	mbien.no_bien=r.getString("no_bien")
	return mbien;
	}
	}
	@RegisterMapper(ModeloBienMapper.class)
	interface BienDAO {
	@SqlUpdate("INSERT INTO test.bien (numero, usuario, password, maquina, sistema, area, ip, no_bien) VALUES(:numero, :usuario, :password, :maquina, :sistema, :area, :ip, :no_bien)")
	void insertar(@Bind("numero") int numero, @Bind("usuario") String usuario, @Bind("password") String password,@Bind("maquina") String maquina,@Bind("sistema") String sistema,@Bind("area") String area,@Bind("ip") String ip, @Bind("no_bien") String no_bien);
	@SqlQuery("SELECT * FROM test.bien where id = :id")
	ModeloBien encontrarPorId(@Bind("id") int id);
	@SqlQuery("SELECT test.bien.id, test.bien.numero, test.bien.usuario, test.bien.password, test.bien.maquina, test.bien.sistema,test.bien.area,test.bien.ip,test.bien.no_bien FROM test.bien")
	List<ModeloBien> verTodo();
	@SqlUpdate("UPDATE test.bien SET numero = :numero, usuario = :usuario, password = :password, maquina = :maquina, sistema = :sistema, area = :area, ip = :ip, no_bien = :no_bien where id = :id")
	void modificarPorId(@Bind("id") int id, @Bind("numero") int numero,@Bind("usuario") String usuario, @Bind("password") String password,@Bind("maquina") String maquina,@Bind("sistema") String sistema,@Bind("area") String area,@Bind("ip") String ip, @Bind("no_bien") String no_bien);
	@SqlUpdate("DELETE FROM test.bien where id = :id")
	void eliminarPorId(@Bind("id") int id);
	void close();
	}

view raw Dao2.groovy hosted with ❤ by GitHub

JDBI con Groovy (2)

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

1. Una clase principal llamada Dao.groovy
2. 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.

	/**
	*
	*@author Codemonkey Junior
	*/
	//compilar: groovyc Dao.groovy
	//ejecutar: groovy Dao.groovy
	@Grapes(
	@Grab(group='org.jdbi', module='jdbi', version='2.77')
	)
	@GrabConfig(systemClassLoader=true)
	@Grab(group='mysql', module='mysql-connector-java', version='5.1.26')
	import java.sql.ResultSet;
	import java.sql.SQLException;
	import org.skife.jdbi.v2.sqlobject.Bind;
	import org.skife.jdbi.v2.sqlobject.SqlQuery;
	import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper;
	import org.skife.jdbi.v2.DBI;
	import org.skife.jdbi.v2.Handle;
	import org.skife.jdbi.v2.tweak.*;
	import org.skife.jdbi.v2.*;
	import org.skife.jdbi.v2.util.*;
	import org.skife.jdbi.v2.sqlobject.Bind;
	import org.skife.jdbi.v2.sqlobject.GetGeneratedKeys;
	import org.skife.jdbi.v2.sqlobject.SqlQuery;
	import org.skife.jdbi.v2.sqlobject.SqlUpdate;
	class Dao{
	static main(args) {
	DBI dbi = new DBI("jdbc:mysql://localhost:3306/test",
	"root",
	"5432");
	MyDAO dao = dbi.open(MyDAO.class);
	String name=null
	try {
	dao.createSomethingTable();
	println "Tabla creada"
	dao.insert(1, "Ariel");
	println "Datos insertados"
	name = dao.findNameById(1);
	println "Hola $name"
	//assertThat(name, equalTo("Ariel"));
	}
	catch(Exception e) {
	println "Error: "+e.toString()
	}
	dao.close();
	}
	}
	interface MyDAO {
	@SqlUpdate("create table prueba (id int primary key, name varchar(100))")
	void createSomethingTable();
	@SqlUpdate("insert into prueba (id, name) values (:id, :name)")
	void insert(@Bind("id") int id, @Bind("name") String name);
	@SqlQuery("select name from prueba where id = :id")
	String findNameById(@Bind("id") int id);
	void close();
	}

view raw Dao.groovy hosted with ❤ by GitHub

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

	/**
	*@author Codemonkey Junior Blogspot
	*@description Usode JDBI en Groovy
	*/
	//importamos la librería JDBI con @Grapes, @Grab
	@Grapes(
	@Grab(group='org.jdbi', module='jdbi', version='2.77')
	)
	//importamos y cargamos el conector MySQL
	@GrabConfig(systemClassLoader=true)
	@Grab(group='mysql', module='mysql-connector-java', version='5.1.6')
	import java.sql.ResultSet;
	import java.sql.SQLException;
	import org.skife.jdbi.v2.sqlobject.Bind;
	import org.skife.jdbi.v2.sqlobject.SqlQuery;
	import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper;
	import org.skife.jdbi.v2.DBI;
	import org.skife.jdbi.v2.Handle;
	import org.skife.jdbi.v2.tweak.*;
	import org.skife.jdbi.v2.*;
	//Clase principal del programa
	class JDBIGroovy{
	static main(args) {
	println "Iniciando ..."
	DBI dbi = new DBI("jdbc:mysql://localhost:3306/test",
	"root",
	"5432");
	println "Abriendo conexion ..."
	Handle h = dbi.open();
	println "Abierto ..."
	if(!dbi.open().isInTransaction()){
	println "No esta realizando alguna transaccion";
	}
	PersonajeDAO pers=null;
	try{
	pers=dbi.open(PersonajeDAO.class);
	if(pers.verTodo().size() > 0){
	println "Lista de persona llena!!: "+pers.verTodo().size();
	println " "+pers.verTodo().toString() != "[null, null, null]" ? "llena" : "vacia";
	//Mostramos todos los resultados
	for(int i=0 ; i < pers.verTodo().size(); i++){
	println "id:"+pers.verTodo().get(i).personaje_id;
	println "nombre:"+pers.verTodo().get(i).nombre;
	println "apellido paterno:"+pers.verTodo().get(i).apellidos;
	println "apellido materno:"+pers.verTodo().get(i).biografia;
	}
	}
	}catch(Exception ex){
	println "Error: "+ex.toString()
	//ex.printStackTrace();
	}finally{
	pers.close();
	}
	h.close();
	}
	}
	//Podemos seguir programando al estilo Java, pero también se puede hacer al estilo Groovy
	//Esta es la clase que representa a la tabla personaje
	class ModeloPersonaje implements java.io.Serializable{
	private static final long serialVersionUID=1L;
	private int personaje_id;
	private String nombre;
	private String apellidos;
	private String biografia;
	public ModeloPersonaje(){}
	public void setPersonaje_Id(int personaje_id){
	this.personaje_id=personaje_id;
	}
	public int getPersonaje_Id(){
	return personaje_id;
	}
	public void setNombre(String nombre){
	this.nombre=nombre;
	}
	public String getNombre(){
	return nombre;
	}
	public void setApellidos(String apellidos){
	this.apellidos=apellidos;
	}
	public String getApellidos(){
	return apellidos;
	}
	public void setBiografia(String biografia){
	this.biografia=biografia;
	}
	public String getBiografia(){
	return biografia;
	}
	}
	//Aquí seteamos los valores obtenidos en la consulta
	class ModeloPersonajeMapper implements ResultSetMapper<ModeloPersonaje> {
	@Override
	public ModeloPersonaje map(int arg0, ResultSet r, StatementContext arg2) throws SQLException {
	ModeloPersonaje mpersonaje=new ModeloPersonaje();
	mpersonaje.setPersonaje_Id(r.getInt("personaje_id"));
	mpersonaje.setNombre(r.getString("nombre"));
	mpersonaje.setApellidos(r.getString("apellidos"));
	mpersonaje.setBiografia(r.getString("biografia"));
	return mpersonaje;
	}
	}
	//Esta clase es donde se ejecutan las consultas SQL
	@RegisterMapper(ModeloPersonajeMapper.class)
	public interface PersonajeDAO {
	@SqlQuery("SELECT test.personaje.personaje_id, test.personaje.nombre, test.personaje.apellidos, test.personaje.biografia FROM test.personaje WHERE test.personaje.personaje_id = :id")
	ModeloPersonaje findById(@Bind("personaje_id") id);
	@SqlQuery("SELECT test.personaje.personaje_id, test.personaje.nombre, test.personaje.apellidos, test.personaje.biografia FROM test.personaje")
	List<ModeloPersonaje> verTodo();
	void close();
	}

view raw JDBIGroovy.groovy hosted with ❤ by GitHub