Grails … un ejemplo

ec564-shomecode4

En este post crearemos un mini sistema para la gestión de tickets de soporte técnico.

¿Qué necesitamos?

  1. Tener instalado el JDK 8
  2. Tener instalado Grails
  3. Tener una BD (usaremos PostgreSQL en este ejemplo)

Tenemos los departamentos o áreas ).

areas

Se levantan los tickets

tickets

El encargado de dar soporte técnico responderá a las peticiones.

respuesta

Analizamos las relaciones.

Un Departamento tiene muchos Ticket(s)

Un Ticket pertenece a un Departamento

Una Respuesta pertenece a un Ticket

Tendremos en total tres clases:

  1. Departamento.groovy
  2. Ticket.groovy
  3. Respuesta.groovy

c2cd9-seleccic3b3n_008

Primer paso: crear el proyecto

$ grails create-app crud-app

Segundo paso: ubicarnos en la carpeta del proyecto creado

$ cd crud-app

Tercer paso: crear las tres clases

$ grails create-domain-class com.codemonkey.model.Departamento
$ grails create-domain-class com.codemonkey.model.Ticket
$ grails create-domain-class com.codemonkey.model.Respuesta

Departamento.groovy

package com.codemonkey.model

class Departamento {
    int iddepartamento
    String nombre
    String responsable

    static constraints = {
        nombre(blank: false)
        responsable(blank: false)
    }

    //Un Departamento tiene muchos Tickets
    static hasMany = [tickets: Ticket]

    String toString(){
        "**Departamento\nId:"+id+"\nNombre:"+nombre+"\nResponsable:"+responsable
    }
}

Ticket.groovy

package com.codemonkey.model

class Ticket {
    int idticket
    Date fecha
    String asunto
    String descripcion

    static constraints = {
        asunto(blank: false)
        descripcion(black: false)
    }

    //Una Tickets pertenece a un Departamento
    static belongsTo = [departamentos: Departamento]

    String toString(){
        "**Ticket\nId:"+id+"\nFecha:"+fecha+"\nAsunto:"+asunto+"\nDescripcion:"+descripcion
    }
}

Respuesta.groovy

package com.codemonkey.model

class Respuesta {
    int idrespuesta
    boolean solucionado
    String descripcion

    static constraints = {
        descripcion(blank: false)
    }

    //Una Respuesta pertenece a un Tickets
    static belongsTo = [tickets: Ticket]

    String toString(){
        String result = solucionado == true? "Solucionado" : "En espera"
        "**Respuesta\nId:"+id+"\nDescripcion:"+descripcion+"\nSolucionado:"+result
    }
}

Cuarto paso: configurar las dependencias necesarias y la conexión a la BD

build.gradle

 buildscript {
repositories {
mavenLocal()
maven { url “https://repo.grails.org/grails/core” }
}
dependencies {
classpath “org.grails:grails-gradle-plugin:$grailsVersion”
classpath “org.grails.plugins:hibernate5:${gormVersion-“.RELEASE”}”
classpath “com.bertramlabs.plugins:asset-pipeline-gradle:2.14.8”
}
}

version “0.1”
group “crud.app”

apply plugin:”eclipse”
apply plugin:”idea”
apply plugin:”war”
apply plugin:”org.grails.grails-web”
apply plugin:”asset-pipeline”
apply plugin:”org.grails.grails-gsp”

repositories {
mavenLocal()
maven { url “https://repo.grails.org/grails/core” }
}

dependencies {
runtime(‘org.postgresql:postgresql’)

compile “org.springframework.boot:spring-boot-starter-logging”
compile “org.springframework.boot:spring-boot-autoconfigure”
compile “org.grails:grails-core”
compile “org.springframework.boot:spring-boot-starter-actuator”
compile “org.springframework.boot:spring-boot-starter-tomcat”
compile “org.grails:grails-web-boot”
compile “org.grails:grails-logging”
compile “org.grails:grails-plugin-rest”
compile “org.grails:grails-plugin-databinding”
compile “org.grails:grails-plugin-i18n”
compile “org.grails:grails-plugin-services”
compile “org.grails:grails-plugin-url-mappings”
compile “org.grails:grails-plugin-interceptors”
compile “org.grails.plugins:cache”
compile “org.grails.plugins:async”
compile “org.grails.plugins:scaffolding”
compile “org.grails.plugins:events”
compile “org.grails.plugins:hibernate5”
compile “org.hibernate:hibernate-core:5.1.5.Final”
compile “org.grails.plugins:gsp”
console “org.grails:grails-console”
profile “org.grails.profiles:web”
runtime “org.glassfish.web:el-impl:2.1.2-b03”
runtime “com.h2database:h2”
runtime “org.apache.tomcat:tomcat-jdbc”
runtime “com.bertramlabs.plugins:asset-pipeline-grails:2.14.8”
testCompile “org.grails:grails-gorm-testing-support”
testCompile “org.grails:grails-web-testing-support”
testCompile “org.grails.plugins:geb:1.1.2”
testRuntime “org.seleniumhq.selenium:selenium-chrome-driver:2.47.1”
testRuntime “org.seleniumhq.selenium:selenium-htmlunit-driver:2.47.1”
testRuntime “net.sourceforge.htmlunit:htmlunit:2.18”
}

bootRun {
jvmArgs(‘-Dspring.output.ansi.enabled=always’)
addResources = true
String springProfilesActive = ‘spring.profiles.active’
systemProperty springProfilesActive, System.getProperty(springProfilesActive)
}

tasks.withType(Test) {
systemProperty “geb.env”, System.getProperty(‘geb.env’)
systemProperty “geb.build.reportsDir”, reporting.file(“geb/integrationTest”)
systemProperty “webdriver.chrome.driver”, System.getProperty(‘webdriver.chrome.driver’)
systemProperty “webdriver.gecko.driver”, System.getProperty(‘webdriver.gecko.driver’)
}

assets {
minifyJs = true
minifyCss = true
}

configurations.all {
resolutionStrategy.cacheDynamicVersionsFor 10, ‘minutes’
}

project.configurations.compile.resolvedConfiguration.resolvedArtifacts.each {
println ‘ [Dependencias] ‘
println ‘artifact: ‘+it.name
println ‘referencia: ‘+it.file
println ‘**************************’
}

application.yml

---
grails:
    profile: web
    codegen:
        defaultPackage: crud.app
    gorm:
        reactor:
            # Whether to translate GORM events into Reactor events
            # Disabled by default for performance reasons
            events: false
info:
    app:
        name: '@info.app.name@'
        version: '@info.app.version@'
        grailsVersion: '@info.app.grailsVersion@'
spring:
    main:
        banner-mode: "off"
    groovy:
        template:
            check-template-location: false

# Spring Actuator Endpoints are Disabled by Default
endpoints:
    enabled: false
    jmx:
        enabled: true

---
grails:
    mime:
        disable:
            accept:
                header:
                    userAgents:
                        - Gecko
                        - WebKit
                        - Presto
                        - Trident
        types:
            all: '*/*'
            atom: application/atom+xml
            css: text/css
            csv: text/csv
            form: application/x-www-form-urlencoded
            html:
              - text/html
              - application/xhtml+xml
            js: text/javascript
            json:
              - application/json
              - text/json
            multipartForm: multipart/form-data
            pdf: application/pdf
            rss: application/rss+xml
            text: text/plain
            hal:
              - application/hal+json
              - application/hal+xml
            xml:
              - text/xml
              - application/xml
    urlmapping:
        cache:
            maxsize: 1000
    controllers:
        defaultScope: singleton
    converters:
        encoding: UTF-8
    views:
        default:
            codec: html
        gsp:
            encoding: UTF-8
            htmlcodec: xml
            codecs:
                expression: html
                scriptlets: html
                taglib: none
                staticparts: none
endpoints:
    jmx:
        unique-names: true

---
hibernate:
    cache:
        queries: false
        use_second_level_cache: false
        use_query_cache: false
dataSource:
    pooled: true
    jmxExport: true
    driverClassName: org.postgresql.Driver # org.h2.Driver
    username: postgres #sa
    password: 5432 #''

environments:
    development:
        dataSource:
            dbCreate: update
            url: jdbc:postgresql://localhost:5432/inventario #jdbc:h2:mem:devDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
    test:
        dataSource:
            dbCreate: update
            url: jdbc:postgresql://localhost:5432/inventario #jdbc:h2:mem:testDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
    production:
        dataSource:
            dbCreate: none
            url: jdbc:postgresql://localhost:5432/inventario #jdbc:h2:./prodDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
            properties:
                jmxEnabled: true
                initialSize: 5
                maxActive: 50
                minIdle: 5
                maxIdle: 25
                maxWait: 10000
                maxAge: 600000
                timeBetweenEvictionRunsMillis: 5000
                minEvictableIdleTimeMillis: 60000
                validationQuery: SELECT 1
                validationQueryTimeout: 3
                validationInterval: 15000
                testOnBorrow: true
                testWhileIdle: true
                testOnReturn: false
                jdbcInterceptors: ConnectionState
                defaultTransactionIsolation: 2 # TRANSACTION_READ_COMMITTED

Quinto paso: generar las vistas, etc.

$ grails generate-all "*"

Sexto paso: ejecutar aplicación

$ grails run-app

Abrir el navegador en: http://127.0.0.1:8080/

Es todo por el momento.

Advertisements

Un vistazo a Grails Framework

cropped-hunger-413685_960_7201.jpg

¿Qué es Grails Framework?

  1. Es un framework para desarrollo de aplicaciones web.
  2. Permite usar Java y Groovy.
  3. Funciona bajo el paradigma Modelo-Vista-Controlador.
  4. Se considera la versión de Ruby on Rails de Java.

Si usas SDKMAN! puedes instalarlo así:

$ sdk install grails

Comprobamos la versión instalada:

$ grails -version

Para crear un proyecto tecleamos lo siguiente:

$ grails create-app my-app

Nos colocamos en la carpeta creada:

$ cd my-app

Creamos un controller:

$ grails create-controller com.codemonkey.controller.Hola

La clase creada (Hola.groovy) se encontrará en:

grails-app/controller/com/codemonkey/controller

Hola.groovy

package com.codemonkey.controller

class Hola{

def index(){

render "Hola, amigos !!"

}

}

Para ejecutar la aplicación:

$ grails run-app

Abrimos nuestro navegador en:

http://127.0.0.1:8080/my-app

Por el momento es todo. En posteriores post escribiremos una aplicación más compleja.

Links

http://codigoprogramacion.com/articulos/programacionweb/ique-es-grails-framework-de-desarrollo-web.html#.Wz1_4-ZG3Dc

https://grails.org/

 

 

Un vistazo a Lambdas Java 8

mug-524103_1920

En este post echaremos un vistazo a las lambdas de Java 8. Las lambdas son una nueva característica en el lenguaje Java 8. Se tratan de funciones que no necesitan pertenecer a alguna clase previamente definida.

La síntaxis básica es la siguiente:

(parámetros) -> { cuerpo-lambda}

Podemos tener algo así:

Operable operable = () -> System.out.println("Hola, mundo!!");
//Donde Operable es una interface

Otros ejemplos:

import static java.lang.System.out;

() -> out.printnl("Bienvenidos al blog");
(int base, int altura) ->{return (base*altura)/2};
(String cadena) -> {String c = cadena;
       c = cadena.toUpperCase();
       return c;
};
Integer entero -> entero.min(7,4) >= 4;
String longitud -> longitud.length() > 10;

Existen cuatro principales tipos de expresiones lambda:

  1. Consumidores (Consumer)
  2. Proveedores (Supplier)
  3. Funciones(Function)
    • Unarios
    • Binarios
  4. Predicados(Predicate)

Para estos ejemplos crearemos una clase llamada Empleado que extiende de una clase Persona.

Persona.java

package com.codemonkey.clases;

import java.util.Collections.*;

public class Persona implements Comparable<Persona>{
		private int id;
		private String nombre;
		private String apellidos;
		private int edad;
		private String aficiones;
		
		public Persona(){}

		public Persona(int id, String nombre,
			String apellidos, int edad, String aficiones){
			this.id=id;
			this.nombre=nombre;
			this.apellidos=apellidos;
			this.edad=edad;
			this.aficiones=aficiones;
		}

		public int getId(){
			return id;
		}

		public void setId(int id){
			this.id=id;
		}

		public String getNombre(){
			return nombre;
		}

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

		public String getApellidos(){
			return apellidos;
		}

		public void setApellidos(String apellidos){
			this.apellidos=apellidos;
		}

		public int getEdad(){
			return edad;
		}

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

		public String getAficiones(){
			return aficiones;
		}

		public void setAficiones(String aficiones){
			this.aficiones=aficiones;
		}

		@Override
		public String toString(){
			return "\nPersona{id:"+id+", nombre:"+nombre
			+", apellidos:"+apellidos+ ", edad:"+edad+", aficiones:"+aficiones+"}";
		}

		@Override
		 public int compareTo(Persona per){  
		 	if(this.id == per.id)
		 		return 0; 
		 	else if(this.id > per.id) 
		 		return 1;
		 	else 
		 		return -1;
		 } 

	}

Empleado.java

package com.codemonkey.clases;

public class Empleado extends Persona {

	private String puesto;
	private int horas;
	private double salario;

	public Empleado(){}

	public Empleado(int id, String nombre,
			String apellidos, int edad, String aficiones,
			String puesto, int horas, double salario) {
		super(id, nombre,apellidos, edad,  aficiones);
		this.puesto = puesto;
		this.horas = horas;
		this.salario = salario;
	}

	public Empleado(String puesto, int horas, double salario) {
		super();
		this.puesto = puesto;
		this.horas = horas;
		this.salario = salario;
	}

	public Empleado(String puesto){
		this(puesto, 0, 0.0);
	}

	public Empleado(int horas){
		this("",horas, 0.0);
	}

	public Empleado(double salario){
		this("", 0, salario);
	}

	public String getPuesto() {
		return puesto;
	}

	public void setPuesto(String puesto) {
		this.puesto = puesto;
	}

	public int getHoras() {
		return horas;
	}

	public void setHoras(int horas) {
		this.horas = horas;
	}

	public double getSalario() {
		return salario;
	}

	public void setSalario(double salario) {
		this.salario = salario;
	}

	@Override
	public String toString() {
		return super.toString()+"::Empleado [puesto=" + puesto + ", horas=" + horas + ", salario=" + salario + "]";
	}

}

Obtener los datos de un empleado usando Consumer.
Consumidores(Consumer)

import java.util.function.Consumer;

//Consumidor: un solo valor y no devuelve valor alguno
Consumer<Empleado> consumerEmp = emp -> System.out.println(emp.toString());
		Empleado empleado = new Empleado("Programador", 10, 120000.00);
		empleado.setId(1);
		empleado.setNombre("Mario");
		empleado.setApellidos("Sanchez Lopez");
		empleado.setEdad(33);
		empleado.setAficiones("Lectura");
		consumerEmp.accept(empleado);

Obtener los datos de un empleado usando Supplier.
Proveedores (Supplier)

import java.util.function.Supplier;

//Proveedor: no tiene parametros de entrada, pero devuelve un resultado
Supplier<Empleado> empSupplier = () -> new Empleado(2, "Armand","Weller", 36, "Natacion","Analista", 12, 22000);
		System.out.println(empSupplier.get());

Obtener el nombre de un empleado usando Function.
Funciones(Function)

import java.util.function.Function;

//Funciones: Reciben un argumento y devuelven un resultado
		Function<Empleado,String> empFunction= (Empleado e)-> {return e.getNombre().concat(" "+e.getApellidos());};
		System.out.println(empFunction.apply(new Empleado(2, "Armand","Weller", 36, "Natacion","Analista", 12, 22000)));

Obtener el puesto (‘Ingeniero’) de un empleado usando Predicate.
Predicados(Predicate)

import java.util.function.Predicate;

//Predicado: reciben un argumento y devuelven un valor logico
		Predicate<Empleado> empPredicate =  emp -> emp.getPuesto().equalsIgnoreCase("Ingeniero");
		if(empPredicate.test(new Empleado(3, "Julio","Matosa", 45, "Ver TV","Ingeniero", 10, 24000))){
			System.out.println("Hola, ingeniero!!");
		}

Código completo:
Main.java

import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.function.Function;
import java.util.function.Predicate;
import com.codemonkey.clases.Empleado;

public class Main{
	public static void main(String[] args){
		//Consumidor: un solo valor y no devuelve valor alguno
		Consumer<Empleado> consumerEmp = emp -> System.out.println(emp.toString());
		Empleado empleado = new Empleado("Programador", 10, 120000.00);
		empleado.setId(1);
		empleado.setNombre("Mario");
		empleado.setApellidos("Sanchez Lopez");
		empleado.setEdad(33);
		empleado.setAficiones("Lectura");
		consumerEmp.accept(empleado);
		
		//Proveedor: no tiene parametros de entrada, pero devuelve un resultado
		Supplier<Empleado> empSupplier = () -> new Empleado(2, "Armand","Weller", 36, "Natacion","Analista", 12, 22000);
		System.out.println(empSupplier.get());
		
		//Predicado: reciben un argumento y devuelven un valor logico
		Predicate<Empleado> empPredicate =  emp -> emp.getPuesto().equalsIgnoreCase("Ingeniero");
		if(empPredicate.test(new Empleado(3, "Julio","Matosa", 45, "Ver TV","Ingeniero", 10, 24000))){
			System.out.println("Hola, ingeniero!!");
		}
		
		//Funciones: Reciben un argumento y devuelven un resultado
		Function<Empleado,String> empFunction= (Empleado e)-> {return e.getNombre().concat(" "+e.getApellidos());};
		System.out.println(empFunction.apply(new Empleado(2, "Armand","Weller", 36, "Natacion","Analista", 12, 22000)));
		
		
	}
}

Links de interés:
https://www.adictosaltrabajo.com/tutoriales/expresiones-lambda-con-java-8/

https://www.codejobs.biz/es/blog/2013/04/12/funciones-lambda-en-python

SQL: Structured Query Language

search-1013910_1920 (copy)

El uso de bases de datos es indispensable en cualquier empresa. Ya sea una pequeña, mediana o grande. El almacenamiento de información puede ofrecer una mejor visión del futuro y ayuda a la toma de decisiones. Imaginemos  escenarios donde se requieren conocer todos contratos efectuados entre los años 1990 y 2015, empleados que han sido ascendidos o removidos de su puesto, calcular los ingresos y egresos de lasúltimas fechas y hacer balance.

Todo esto puede realizarse gracias a un gestor de bases de datos.

En este post usaremos MySQL. MySQL es un gestor relativamente modesto comparado con otros gestores como Oracle y PostgreSQL. Sin embargo, es recomendable para aprender SQL y familiarizarse con su uso.

Pero antes de nada, ¿Qué es SQL?

Se trata de las siglas (en inglés) de Structured Query Language. Un lenguaje especial para la creación y manipulación de la información contenida en tablas de información perteneciente a una base de datos.

El SQL se divide en:

  1. DCL: Data Control Language (GRANT/REVOQUE).
  2. TCL: Transaction Control Language (COMMIT/ROLLBACK/SAVEPOINT).
  3. DDL: Data Definition Language(CREATE/ALTER/DROP/RENAME/TRUNCATE).
  4. DML:Data Manipulation Language(INSERT/SELECT/UPDATE/DELETE).

En próximos post veremos ejemplos de cada uno de ellos. Por el momento nos enfocaremos en el uso de MySQL.

En este link puedes ver cómo instalar MySQL (si usas Linux): https://www.digitalocean.com/community/tutorials/how-to-install-mysql-on-ubuntu-16-04

En una terminal escribimos:

mysql -u tuUsuario -p tuClave

Una vez dentro crearemos una base de datos denominada ’empresa’.

DROP DATABASE IF EXISTS empresa;
CREATE DATABASE IF NOT EXISTS empresa;

Mostramos todas las bases de datos:

SHOW DATABASES;

Indicaremos que queremos usar la base de datos previamente creada:

USE empresa;

Crearemos dos tablas denominadas ‘departamentos’ y ’empleados’ respectivamente.
departamentos: departamento, descripcion
empleados: idempleado, nombre, apellidos, edad, salario, puesto, sexo,fecha de ingreso y departamento al que pertenece

DROP TABLE IF EXISTS empleados;
DROP TABLE IF EXISTS departamentos;
CREATE TABLE IF NOT EXISTS departamentos(departamento CHAR(3) NOT NULL PRIMARY KEY, descripcion VARCHAR(50));
CREATE TABLE IF NOT EXISTS empleados(idempleado INT NOT NULL AUTO_INCREMENT PRIMARY KEY, nombre VARCHAR(50), apellidos VARCHAR(50), edad INT, salario INT, puesto VARCHAR(50), sexo ENUM('M','F'), fecha_ingreso DATE, departamento CHAR(3), FOREIGN KEY (departamento) REFERENCES departamentos(departamento) );

Insertaremos algunos valores.

INSERT INTO empresa.departamentos(departamento,descripcion) VALUES ('AE1',"Departamento de cobranzas"),('BC2',"Departamento de finanzas"),('BC1',"Control de gestiones");
INSERT INTO empresa.empleados(nombre, apellidos, edad, salario, puesto, sexo, fecha_ingreso, departamento) VALUES ("Martin","Morales Torres",23, 12000, "Promotor", 'M','2018-02-09','AE1'),("Ignacio","Juarez Aldama",30,15000,"Contador",'M','2017-09-04',"BC2"),("Maria Magdalena","Garcia Sanchez",35,16000,"Contador",'F','2017-12-09',"AE1"),("Horacio","Arzate Contreras",60,21000,"Abogado",'M','1990-12-06','BC1');

Actualizaremos el salario de los empleados femeninos.

UPDATE empresa.empleados SET salario=20000 WHERE sexo='F';

Mostraremos a los empleados del sexo femenino

SELECT * FROM empresa.empleados WHERE sexo='F';

Mostraremos a los empleados de sexo masculino.

SELECT * FROM empresa.empleados WHERE sexo='M';

Eliminaremos a los empleados del departamento ‘BC1’

DELETE FROM empresa.empleados WHERE empleados.departamento='BC1';

Fin del post.
 

 

JPA, ejemplo de anotaciones

Cuando programamos en Java muchas veces tenemos la necesidad de hacer uso de bases de datos. Anteriormente se usaba (aunque algunos lo siguen usando) JDBC. No obstante, el uso de JPA es lo más usual hoy en día.

Imaginemos que tenemos dos tablas Empleado y Departamento con sus respectivos campos. Para enlazar nuestra aplicación no solo es necesario contar con los drivers necesarios para establecer la conexión a las bases de datos (MySQL, Postgresql, Oracle, etc.), también es indispensable establecer la lógica de las entidades.

Empleado dependerá de un Departamento, por ejemplo, Sistemas para los programadores y Contabilidad para los contadores. La entidad Departamento puede tener más de un empleado, pero la entidad Empleado no puede pertenecer a más de un departamento.

¿Cómo podemos crear una relación entre éstas dos entidades?

Para ello tenemos las anotaciones JPA.
@OneToMany , para establecer una relación de uno a muchos. Ideal para Departamento.
@ManyToOne, para establecer una relación de muchos a uno. Para Empleado que sólo puede pertenecer a un departamento.
La anotación @JoinColumn nos servirá para definir la clave externa (la del departamento).

c2cd9-seleccic3b3n_008

Pasemos a la codificación de las entidades.

Tenemos a Empleado.

Empleado.java

package com.codemonkey.model;

import javax.persistence.*;

@Entity
@Table(name="empleado")
public class Empleado implements java.io.Serializable{
  @Id
  @GeneratedValue(strategy=GenerationType.AUTO)
  @Column(name="idempleado")
  private int idempleado;

  @ManyToOne
  @JoinColumn(name="iddepartamento")
  private Departamento departamento;
  //constructores
  //métodos de acceso
}

@Id, indica la llave primaria

@GeneratedValue(strategy=GenerationType.AUTO), esto índica que la clave será auto incrementable.

@Column, nos sirve para especificar el nombre de la columna en nuestra tabla de información.

Ahora tenemos a Departamento.

Departamento.java

package com.codemonkey.model;

import javax.persistence.*;
import java.util.List;

@Entity
@Table(name="departamento")
public class Departamento implements java.io.Serializable{
  @Id
  @Column(name="iddepartamento")
  private int iddepartamento;

  @OneToMany(mappedBy="departamento")
  private List empleados;
  //constructores
  //métodos de acceso
}

Clases en Python

ec564-shomecode4

Programar en Python puede parecer complejo para ciertas personas. Sin embargo, para muchas otras es muy fácil.

Para muestra pasa un botón (una clase):

persona.py

class Persona(object):
     pass

Esta clase (Persona) puede terner atributos:

  • nombre
  • apellidos
  • edad
  • dirección
  • email
  • teléfono
class Persona(object):
	def __init__(self, nombre,apellidos,edad, direccion, email,telefono):
		self.nombre=nombre
		self.apellidos=apellidos
		self.edad=edad
		self.direccion=direccion
		self.email=email
		self.telefono=telefono
		print "Objeto Persona creado e inicializado"

¿Así de fácil? Sí. Y más. ¿Podemos crear herencia? Claro. Crearemos una clase hija denominada Empleado con dos atributos (puesto y horas laboradas).

class Empleado(Persona):
	def __init__(self,puesto,horas,nombre,apellidos,edad, direccion, email, telefono):
		super(Empleado,self).__init__(nombre,apellidos,edad, direccion, email, telefono)
		self.puesto=puesto
		self.horas=horas
		print "Objeto Empleado creado e inicializado"

La clase Empleado no solo tendrá su propios atributos sino que también heredará atributos de la case padre (Persona).

La instanciación es similar a la usada en lenguajes como Java.

def main():
#Persona
	my_persona = Persona("Genaro","Moreno",36, "Aldama no. 333, Toluca, Edo. Mex.","genaro@hotmail.com","444-555-00")
	print "Nombre:",my_persona.nombre
	print "Apellidos:",my_persona.apellidos
	print "Edad:",my_persona.edad
	print "Direccion:",my_persona.direccion
	print "Email:",my_persona.email
	print "Telefono:",my_persona.telefono

#Empleado
	my_empleado = Empleado("Administrador", 12, "Adrian","Chavez",45,"Juarez no. 55, Ecatepec","chavez@latinmail.com","555-998-00")
	print "Puesto:",my_empleado.puesto
	print "Horas trabajadas:",my_empleado.horas
	print "Nombre:",my_empleado.nombre
	print "Apellidos:",my_empleado.apellidos
	print "Edad:",my_empleado.edad
	print "Direccion:",my_empleado.direccion
	print "Email:",my_empleado.email
	print "Telefono:",my_empleado.telefono

#Método main
if __name__ == '__main__':
	main()

Links:
http://codemonkeyjunior.blogspot.mx

Servicio REST Api con Spring Data

Creamos un Proyecto Nuevo en https://start.spring.io/

Elegiremos Maven para la creación del ejemplo.

Screenshot_1

En la sección SQL elegimos JPA y PostgreSQL.

Screenshot_2

En la sección WEB elegimos Web y Rest Repositories

Screenshot_3

Finalizamos y descargamos el ejemplo. Debe quedar así en nuestro directorio.

Screenshot_4

Abrimos una terminal en el directorio y tecleamos:

mvn clean install

Maven se encargará de descargar las librerías necesarias para el proyecto.

Agregamos plugin para Eclipse IDE

mvn eclipse:eclipse

Ahora abrimos Eclipse e importamos proyecto Maven existente

Screenshot_5

Elegimos nuestro proyecto

Screenshot_6

Revisamos dependencias necesarias en el pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.codemonkey</groupId>
    <artifactId>api-rest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>api-rest-ejemplo</name>
    <description>Uso de API Rest Spring Data</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope> </dependency> -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project><span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			></span>

Creamos una tabla alumno.
Screenshot_7

Insertamos valores.

INSERT INTO public.alumno(nombre, apellidos, direccion, telefono, email)
	VALUES ('Zuzanne', 'Waller', 'Tomahawk no. 100', '555-766', 'zuzanewll@gmail.com'),('Yohanan', 'Diaz', 'Toluca, Edo. Mex.', '555-111', 'genaro.amaro@latinmail.com');

Screenshot_8

Creamos clase Alumno.java

package com.codemonkey.entity;

import java.io.Serializable;

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

@Entity
@Table(name="alumno")
public class Alumno implements Serializable{
	private static final long serialVersionUID = 1L;
	@Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
	private int id;
	@Column(name = "nombre")
	private String nombre;
	@Column(name = "apellidos")
	private String apellidos;
	@Column(name = "direccion")
	private String direccion;
	@Column(name = "telefono")
	private String telefono;
	@Column(name = "email")
	private String email;

	public Alumno() {}

	public Alumno(int id, String nombre, String apellidos, String direccion, String telefono, String email) {
		super();
		this.id = id;
		this.nombre = nombre;
		this.apellidos = apellidos;
		this.direccion = direccion;
		this.telefono = telefono;
		this.email = email;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getNombre() {
		return nombre;
	}

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

	public String getApellidos() {
		return apellidos;
	}

	public void setApellidos(String apellidos) {
		this.apellidos = apellidos;
	}

	public String getDireccion() {
		return direccion;
	}

	public void setDireccion(String direccion) {
		this.direccion = direccion;
	}

	public String getTelefono() {
		return telefono;
	}

	public void setTelefono(String telefono) {
		this.telefono = telefono;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	@Override
	public String toString() {
		return "Alumno [id=" + id + ", nombre=" + nombre + ", apellidos=" + apellidos + ", direccion=" + direccion
				+ ", telefono=" + telefono + ", email=" + email + "]";
	}

}

Creamos un Repositorio de datos

package com.codemonkey.repository;

import org.springframework.data.repository.PagingAndSortingRepository;

import com.codemonkey.entity.Alumno;

public interface AlumnoRepository extends PagingAndSortingRepository<Alumno, Integer>{
}

Clases principales de la aplicación.
ApiRestEjemploApplication.java

package com.codemonkey;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ApiRestEjemploApplication {

	public static void main(String[] args) {
		SpringApplication.run(ApiRestEjemploApplication.class, args);
	}
}

SpringApplicationBuilder.java

package com.codemonkey;

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
		return application.sources(ApiRestEjemploApplication.class);
	}

}

application.properties

spring.data.rest.basePath=/api

#MySQL
#spring.datasource.url=jdbc:mysql://localhost:3306/proyecto
#spring.datasource.username=root
#spring.datasource.password=root
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#POSTGRESQL
spring.jpa.generate-ddl=true
spring.jpa.show-sql=true
spring.datasource.driverClassName=org.postgresql.Driver
spring.datasource.url=jdbc:postgresql://localhost:5432/proyecto
spring.datasource.username=postgres
spring.datasource.password=5432
#spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.hibernate.ddl-auto=update
#spring.jpa.hibernate.ddl-auto=create
spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.ImprovedNamingStrategy

# JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration)
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect

Ejecutamos la aplicación y abrimos el navegador en la dirección

http://localhost:8080/api/alumnoes

Links:

https://geeks-mexico.com/2018/01/04/crea-un-api-rest-de-la-forma-mas-simple-con-java-y-spring-data-rest/

https://start.spring.io/

Instalando Spring y Gradle en Eclipse

¿Qué necesitamos? Descargar Eclipse for Java EE Developers aquí: http://www.eclipse.org/downloads

Una vez abierto el ide. Ir a la pestaña Help y elegir Eclipse Marketplace. Teclear Spring Framework y dar enter. Elegir Spring Tools.

Screenshot_1

Dar clic en botón Install. Se inicializará la instalación:

Screenshot_2

Confirmar y finalizar:

Screenshot_3

Finalizar:

Screenshot_4

Comprobamos instalación:

Screenshot_5

Instalando Gradle.

Help -> Marketpplace y teclear Gradle. Elegir Buildship Gradle Integration y dar clic en Install. También podemos elegir el editor Gradle.

Screenshot_6

El proceso finalizará y reiniciamos el IDE.