Ejecutar proyectos Kotlin con Maven

maven java logo

En esta ocasión veremos cómo ejecutar un proyecto Kotlin desde Maven.

<?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/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>spark-kotlin</groupId>
    <artifactId>spark-kotlin</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spark-kotlin spark-kotlin</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <kotlin.version>1.0.6</kotlin.version>
        <junit.version>4.12</junit.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib</artifactId>
            <version>${kotlin.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-test-junit</artifactId>
            <version>${kotlin.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.sparkjava</groupId>
            <artifactId>spark-core</artifactId>
            <version>2.5.4</version>
        </dependency>
        <dependency>
            <groupId>com.sparkjava</groupId>
            <artifactId>spark-template-velocity</artifactId>
            <version>2.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.module</groupId>
            <artifactId>jackson-module-kotlin</artifactId>
            <version>2.8.4</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.22</version>
        </dependency>
    </dependencies>

    <build>
        <sourceDirectory>src/main/kotlin</sourceDirectory>
        <testSourceDirectory>src/test/kotlin</testSourceDirectory>

        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <version>${kotlin.version}</version>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>attached</goal>
                        </goals>
                        <phase>package</phase>
                        <configuration>
                            <descriptorRefs>
                                <descriptorRef>jar-with-dependencies</descriptorRef>
                            </descriptorRefs>
                            <archive>
                                <manifest>
                                    <mainClass>app.MainKt</mainClass>
                                </manifest>
                            </archive>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>

    </build>

</project>

Main.kt

package com.codemonkey

fun main(args:Array<String>) {
   println("Hola, mundo");
}

Creamos, compilamos y empaquetamos proyecto.

mvn clean install
mvn package

Ejecutamos:

java -jar target/proyectokotlin-1.0-SNAPSHOT-jar-with-dependencies.jar 
Advertisements

Spring Boot + Vue JS

cafe-151346_640

En esta ocasión veremos como usar Vue JS en una aplicación Spring Boot.

Creamos nuestra tabla contacto.

contacto.sql

CREATE DATABASE IF NOT EXISTS prueba;

USE prueba;

CREATE TABLE IF NOT EXISTS contacto(id int auto_increment primary key, nombre varchar(100), telefono varchar(12) not null, fecha datetime);

Insertamos algunos valores.

INSERT INTO contacto (nombre,telefono,fecha) VALUES ('Daniel Alcantara','76662323', now()), ('Tomas Torres','5559099', now());

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>servidor</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<name>servidor</name>
	<description>Servidor de servicio web</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.5.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-thymeleaf</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web-services</artifactId>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</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>
		
		<dependency>
		    <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-starter-web-services</artifactId>
		</dependency>
		<dependency>
		    <groupId>wsdl4j</groupId>
	        <artifactId>wsdl4j</artifactId>
		</dependency>

        <dependency>
		   <groupId>org.slf4j</groupId>
           <artifactId>slf4j-api</artifactId>
           <version>1.6.1</version>
		</dependency>

        <dependency>
		  <groupId>org.springframework.data</groupId>
		  <artifactId>spring-data-rest-core</artifactId>
		  <version>3.1.1.RELEASE</version>
		</dependency>

	</dependencies>

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


<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>jaxb2-maven-plugin</artifactId>
    <version>1.6</version>
    <executions>
      <execution>
        <id>xjc</id>
        <goals>
          <goal>xjc</goal>
        </goals>
      </execution>
    </executions>
    <configuration>
      <schemaDirectory>${project.basedir}/src/main/resources</schemaDirectory>
      <outputDirectory>${project.basedir}/src/main/java/com/codemonkey/clases</outputDirectory>
      <clearOutputDir>false</clearOutputDir>
    </configuration>
  </plugin>


		</plugins>
	</build>


</project>

Nuestro archivo application.yml tendrá el siguiente aspecto:
application.yml

#BANNER
banner:
   charset: UTF-8
   location: banner.txt

spring:
   thymeleaf:
      cache: false
      check-template: true
      check-template-location: true
      content-type: text/html
      enabled: true
      encoding: UTF-8
      suffix: .html
   jpa:
      generate-ddl: true
      database-platform: org.hibernate.dialect.MySQL5Dialect
      show-sql: false
      hibernate.ddl-auto: update
      hibernate.naming-strategy: org.hibernate.cfg.ImprovedNamingStrategy
   servlet.multipart.max-file-size: 128KB
   servlet.multipart.max-request-size: 128KB
   http.multipart.enabled: false
   datasource.url: jdbc:mysql://localhost:3306/prueba?useSSL=false
   datasource.driver-class-name: com.mysql.jdbc.Driver
   datasource.username: root
   datasource.password: root

Nuestra entidad Contacto.java. Usaremos la librería lombok para ahorrar escribir código.

package com.codemonkey.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Setter;
import lombok.ToString;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.time.LocalDate;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.GenerationType;
import javax.persistence.Table;


@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@Table(name="contacto")
@Entity(name="Contacto")
public class Contacto implements java.io.Serializable{
    private static final long serialVersionUID = 7526472295622776147L;
    
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    @Getter @Setter public int id;
    @Column(name="nombre")
    @Getter @Setter public String nombre;
    @Column(name="telefono")
    @Getter @Setter public String telefono; 
    @Column(name="fecha")
    @Getter @Setter public LocalDate fecha;
}

Ahora un repositorio.
ContactoCrudRepository.java

package com.codemonkey.repository;

import java.util.List;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import com.codemonkey.model.Contacto;

public interface ContactoCrudRepository extends CrudRepository{

    @Query(value="SELECT * FROM contacto ORDER BY id ",nativeQuery=true)
    public List<Contacto> getAllContactos(); 
}

Es necesario notar que dentro de la anotación @Query podemos declarar una consulta SQL nativa. En est caso SELECT * FROM contacto ORDER BY id.

El siguiente paso es declarar un servicio y su implementación.

package com.codemonkey.service;

import java.util.List;
import com.codemonkey.model.Contacto;

public interface ContactoCrudService{
    public List<Contacto> getAllContactos();
}

La implementación de este servicio sería el siguiente:

package com.codemonkey.service.impl;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;

import com.codemonkey.repository.ContactoCrudRepository;
import com.codemonkey.service.ContactoCrudService;
import com.codemonkey.model.Contacto;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


@Service("contactoCrudService")
public class ContactoCrudServiceImpl implements ContactoCrudService{
    private final Logger LOGGER = LoggerFactory.getLogger(ContactoCrudServiceImpl.class);

    @Autowired
    private ContactoCrudRepository contactoCrudRepository;
    
    @Override
    public List<Contacto&gt getAllContactos(){
        LOGGER.info("--Has entrado a getAllContactos");
        return contactoCrudRepository.getAllContactos();
    }
} 

Creamos el ContactoRestController.java

package com.codemonkey.controller;

//import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import com.codemonkey.model.Contacto;
import com.codemonkey.service.ContactoCrudService;


@RestController
@RequestMapping("/rest")
public class ContactoRestController{

    private final Logger LOGGER = LoggerFactory.getLogger(ContactoRestController.class);
       
    //@Qualifier("contactoService")
    @Autowired
    private ContactoCrudService contactoCrudService;

    //http:localhost:8080/rest/contactosRest
    @GetMapping("/contactosRest")
    public List<Contacto&gt getAllContactos(){
        LOGGER.info("--Has entrado a http://localhost:8080/rest/contactosRest");
        return contactoCrudService.getAllContactos();
    }
}

Ahora una vista. Antes deberíamos aclarar que debemos la importar tres archivos necesarios para trabajar con Vue JS.

<!--Vue JS -->
<script
  src="https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.js">
</script>
<script
  src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/6.21.1/babel.min.js">
</script>
<!--axios-->
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

contactosVueJS.html

<!DOCTYPE html>
<html lang="es"
      xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">
    <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
        <title>Contactos</title>
        <script type="text/javascript" src="/js/funciones.js"></script>
        <link rel="stylesheet" type="text/css" media="all" href="css/estilos.css" th:href="@{css/estilos.css}" />
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css"/>
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.3/umd/popper.min.js"></script>
  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js"></script>
  <!--Vue JS -->
<script
  src="https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.js">
</script>
<script
  src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/6.21.1/babel.min.js">
</script>
<!--axios-->
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

    </head>
    <body>
<div class="jumbotron text-center">
   <h1 align="center" class="bg-dark text-white">Contactos</h1><br/>
   <a href="#" th:href="@{/proyecto/home}" title="regreso">Home</a>
</div>

<div id="my_app">    
    <div class="table-responsive">
        <table class="table table-dark table-striped" style="font-family: Chakra Petch">
            <thead >
                <tr>
                    <th>Nombre</th>
                    <th>Teléfono</th>
                </tr>
            </thead>
            <tbody>
                <tr v-for="data in contactos">
                    <td> <p contenteditable="true">{{ data.nombre }} </p></td>
                    <td><p contenteditable="true">{{ data.telefono }}</p></td>
                    
                </tr>
            </tbody>
        </table></div>

</div>

<script>
var my_app = new Vue({
    el:'#my_app',
    data(){
        return {
            contactos:[]
        };
    },
    methods:{
        getContactos(){
            axios
            .get('http://localhost:8080/rest/contactosRest')
            .then((data) => {
                this.contactos = data.data
            });
        }
    },
    mounted(){
        this.getContactos()
    },
});
</script>
</body>
</html>

En el fragmento de código javascript podemos analizar lo siguiente

//Creamos un objeto tipo Vue y sus atributos, en este caso el id será "my_app"
   var my_app = new Vue({
    el:'#my_app',
    data(){
        return {
            contactos:[]
        };
    },   //Declaramos un método getContactos() que hace una invocación
// al método get(URL) de axios, en esa URL esta nuestro servicio rest
    methods:{
        getContactos(){
            axios
            .get('http://localhost:8080/rest/contactosRest')
            .then((data) => {
                this.contactos = data.data
            });
        }
    },
    mounted(){
        this.getContactos()
    },
});

Dentro del fragmento HTML se puede observar lo siguiente:

<div id="my_app">    
    <div class="table-responsive">
        <table class="table table-dark table-striped" style="font-family: Chakra Petch">
            <thead >
                <tr>
                    <th>Nombre</th>
                    <th>Teléfono</th>
                </tr>
            </thead>
            <tbody>
                <tr v-for="data in contactos">
                    <td> <p contenteditable="true">{{ data.nombre }} </p></td>
                    <td><p contenteditable="true">{{ data.telefono }}</p></td>
                    
                </tr>
            </tbody>
        </table></div>

</div>

En esta parte accedemos a los atributos nombre y telefono:

{{ data.nombre }}
{{ data.telefono }}

¡Feliz código!

Clases , herencia e interfaces en Typescript

code-3337044_640

Typescript es un lenguaje de tipado estático muy parecido a Java. Al igual que Java posee tipos básicos de datos(number,string,boolean, etc.) y tipos clase (new Number(), new String(), etc.). La creación de clases también es muy similar.

Herencia.

Una clase padre puede heredar atributos y métodos a una clase hija.

Clase padre/superclase Abstracta.

abstract class Abstracta{
	abstract nada():void;
}

Dentro de la superclase Abstracta definimos un método abstracto llamando nada. Recordar que un método abstracto no necesita un cuerpo, sólo la firma(nombre del método y tipo).

Y tendremos dos clases hijas/subclases Hijo e Hija. Por obligación y contrato las subclases deben adoptar los atributos y comportamiento de la superclase.

class Hijo extends Abstracta{
	nada():void{
		console.log("Nada en hijo")
	}
}

class Hija extends Abstracta{
	nada():void{
		console.log("Nada en hija");
	}
}

Observamos que ambas clases implementan el método nada como a ellas les conviene. Ahora las instancias.

let hijo:Hijo=new Hijo();
let hija:Hija=new Hija();
hijo.nada();//Nada en hijo
hija.nada();//Nada en hija

Una clase abstracta no puede ser instanciada, su función es que otras clases hereden de ella.

Recordar que no podemos hacer algo como esto:

//Esto no se puede/debe hacer:
let abstracta: Abstracta= new Abstracta();
//La finalidad de una clase abstract es que hereden de ella,
// no se puede instanciar

El compilador nos dirá que no es posible instanciar una clase abstracta (al igual que en Java).

Interfaces

Una interface es una clase totalmente abstracta. Se pueden definir métodos sin cuerpo.

Síntaxis:

export interface NombreInterface{
   //...
}

Crearemos una interface llamada Servicio con un método (abstract) denominado operacion con dos parámetros.

interface Servicio{
	operacion(x:number,y:number):number;
}

Ahora crearemos dos clases que implementarán el método de la interface Servicio.


/*La clase Suma sumará dos números*/
class Suma implements Servicio{
	operacion(x:number,y:number):number{
		return x+y;
	}
}

/*La clase IMC calculará el índice de masa corporal de una persona*/
class IMC implements Servicio{
	operacion(peso:number,talla:number):number{
		return peso/(talla*talla);
	}
}


/*instanciamos a la clase Suma*/
let suma:Suma=new Suma();

/*instanciamos a la clase IMC*/
let imc:IMC=new IMC();

/*Mostramos los resultados de las operaciones*/
console.log(suma.operacion(3,6));//9
console.log(imc.operacion(60,1.55));//24.973985

¡Feliz código!

Typescript ::Clases

flat-2126884_1280

En post anteriores (uno y dos) vimos como crear, compilar y ejecutar un proyecto usando Typescript , ahora veremos un concepto muy importante: las clases.

Una clase básicamente es el modelo que posee atributos y métodos, y un objeto es una instancia de ese modelo.

Síntaxis

Clase ref = new Constructor();

Con Typescript podemos crear clases de manera similar a los lenguajes orientados a objetos como Java y C# (entre otros más).

En nuestro proyecto del post anterior teníamos el siguiente directorio:

 proyecto/src/index.ts
 proyecto/src/modelo
 proyecto/tsconfig.json
 proyecto/dist

Es importante editar el archivo tsconfig.json
tsconfig.json

{
  "compilerOptions": {
    "target": "es5",                         
    "module": "commonjs",                   
    "sourceMap": true, 
    "outDir": "./dist", 
    "strict": true,  
    "esModuleInterop": true   
  }
}

 

 

Ahora bien, crearemos dos clases Punto (punto.ts) y PuntoColor (puntocolor.ts)

 proyecto/src/index.ts
 proyecto/src/modelo/punto.ts
 proyecto/tsconfig.json
 proyecto/dist

punto.ts

export class Punto{
	x: number;
	y: number;

	constructor(x:number,y:number){
		this.x = x;
		this.y = y;
	}

	getPunto(){
		return "Punto("+this.x+","+this.y+")";
	}
}

Nota: usaremos export para definirla como módulo y poder importarla en index.ts.

Haremos lo mismo:

 proyecto/src/index.ts
 proyecto/src/modelo/punto.ts
 proyecto/src/modelo/puntocolor.ts
 proyecto/tsconfig.json
 proyecto/dist

puntocolor.ts

import {Punto} from "./punto";

export class PuntoColor extends Punto{
	color:string;
	constructor(x:number, y:number,color:string){
		super(x,y);
		this.color = color;
	}

	getPuntoColor(){
		return "PuntoColor("+this.color+","+this.x+","+this.y+")";
	}
}

Es importante notar que usamos extends para señalar que PuntoColor es clase hija de Punto.

    Punto <- Clase padre
     |
  PuntoColor <- Clase hija

Importaremos ambas clases en el archivo index.ts usando import muy al estilo de lenguajes como Java, Python, etc.

import {Clase} from "./directorioDondeSeEncuentraClase/clase";

Nota: A pesar que definimos el nombre del archivo en minúsculas, es necesario respetar la síntaxis del lenguaje.

index.ts

//Importamos ambas clases, respetando el uso de mayúsculas
import {Punto} from "./modelo/punto";
import {PuntoColor} from "./modelo/puntocolor";

//instanciamos clase Punto
let my_punto: Punto = new Punto(2,4);
console.log("Salida: ",my_punto.getPunto());

//instanciamos clase PuntoColor
let my_puntoColor : PuntoColor = new PuntoColor(4,7,"Verde");
console.log("Salida: ",my_puntoColor.getPuntoColor());

Compilamos:

$ tsc --watch

Ejecutamos:

$ node dist/

Tipos básicos en Typescript

ec564-shomecode4

Typescript es un lenguaje de programación que compila a código javascript. La extensión que usa es la *.ts (Ej. nodo.ts, gato.ts, etc.)

En el post anterior se habló de su instalación y un ejemplo básico. En esta ocasión crearemos un archivo llamado index.ts mostrando los tipos básicos.

Antes de nada creamos un directorio y nos ubicamos en el:

$ mkdir basico
$ cd basico

Iniciamos un proyecto con tsc –init y listamos el directorio para ver el archivo generado.

$ tsc --init
$ ls

El archivo generado se llama tsconfig.json. Debemos modificarlo para que nos quede de la siguiente forma.

tsconfig.json

{
  "compilerOptions": {
    "target": "es5",                          
    "module": "commonjs",                    
    "sourceMap": true,                    
    "outDir": "./dist",                       
    "strict": true,                           
    "esModuleInterop": true                   
  }
}

Dentro del directorio principal (basico) debemos tener una carpeta src. Ahí crearemos el archivo index.ts.

En Typescript tenemos tipos number, string, boolean, etc. Recodermos que es un lenguaje de tipado estático (al menos esa es la idea) y por ende es necesario, en algunos casos, delarar el tipo de variable a usar.

Una declaración sencilla (declarando una variable tipo ‘Int’):

let entero: number = 33;

Un tipo string y/o char:

let caracter: string = 'X';
let cadena: string = "En un lugar lejano del viejo oeste.";

Un tipo booleano:

let booleano: Boolean;
booleano = false;

Un tipo null e undefined:

let indefinido = undefined;
let nulo = null;

También podemos definir arreglos:

//Un arreglo tipo 'Int'
let arregloEnteros : Array<number> ;
arregloEnteros=[1,2,3,4,5];

//Un arreglo tipo string
let arregloString : Array<string> = ["A","B","C"];

Para recorrer estos arreglos podemos usar el clásico for o la forma ‘for each’:

//for clásico
for(var i=0 ; i < arregloEnteros.length; i++){
	console.log(arregloEnteros[i]);
}

//for for each
console.log("foreach:");
for(let arr of arregloString){
	console.log(arr);
}

Código completo:
index.ts

let caracter: string = 'X';
let entero: number = 33;
let binario: number = 0b11101 ;
let flotante: number = 34.55;
let cadena: string = "En un lugar lejano del viejo oeste.";
let booleano: boolean = false;
let indefinido = undefined;
let nulo = null;
let arregloEnteros : Array<number>
arregloEnteros=[1,2,3,4,5];
let arregloString : Array<string> = ["A","B","C"];
console.log("Typescript funcionando!!");
console.log("Caracter: ",caracter);
console.log("Entero: ",entero);
console.log("Binario: ",binario);
console.log("Flotante: ",flotante);
console.log("Cadena: ",cadena);
console.log("Booleano: ",booleano);
console.log("Undefined: ",indefinido);
console.log("Null: ",nulo);
console.log("for clasico:");
for(var i=0 ; i < arregloEnteros.length; i++){
	console.log(arregloEnteros[i]);
}
console.log("foreach:");
for(let arr of arregloString){
	console.log(arr);
}

Compilamos con:

$ tsc --watch

Ejecutamos con:

$ node dist/

Si no marca ningún error nos debería mostrar lo siguiente:

typescript

Gradle + Kotlin

ec564-shomecode4
Trabajar con una herramienta como Gradle facilita el trabajo a los programadores. En este post veremos un ejemplo del uso de Kotlin con Gradle.

gradle.build

buildscript {
    ext.kotlin_version = '1.3.10'

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

apply plugin: 'kotlin'
apply plugin: 'application'

mainClassName = "com.codemonkey.Main"

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
}

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

package com.codemonkey

object Main {
   @JvmStatic
   fun main(args:Array){
     println("Hola,mundo!!")
   }
}

Construimos el proyecto.

$ gradle build

Ejecutamos el proyecto.

$ gradle run

Kotlin

user-154199_640

Para instalar Kotlin debemos descargar el compilador de la siguiente página: https://github.com/JetBrains/kotlin/releases/tag/v1.3.0

Una vez descargado se procede a descomprimir el archivo y crear el path. En Windows puede ser así: C:\kotlinc\bin

Con plataformas Linux puedes usar SDKMAN!

$ sdk install kotlin

Comenzaremos con el clásico Hola, mundo!

hola.kt

package examples

fun main(){
println("Hola, mundo!")
}

Compilamos:

$ kotlinc hola.kt -include-runtime -d hola.jar

Ejecutamos:

$ java -jar hola.jar

¡Listo! Hemos creado nuestro primer programa en Kotlin.

Spring + Maven

user-154199_640

En está serie de post hemos visto como crear y ejecutar aplicaciones Java y Spring con Maven. He aguí otro ejemplo más.

pom.xml

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.codemonkey</groupId>
  <artifactId>Inicio</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>Inicio</name>
  <url>http://maven.apache.org</url>
  <properties>
    <spring.version>3.0.5.RELEASE</spring.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  <!-- Spring 3 dependencies -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <!-- JavaConfig need this library -->
  <dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
  </dependency>
  </dependencies>
</project>

HelloWorld.java

package com.codemonkey.interfaces;

public interface HelloWorld{
    void printHelloWorld(String msg);
}

HelloWorldImpl.java

package com.codemonkey.clases;

import com.codemonkey.interfaces.HelloWorld;

public class HelloWorldImpl implements HelloWorld{

    public void printHelloWorld(String msg) {
        System.out.println("Hola : " + msg);
    }
}

AppConfig.java

package com.codemonkey.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.codemonkey.interfaces.HelloWorld;
import com.codemonkey.clases.HelloWorldImpl;

@Configuration
public class AppConfig {

    @Bean(name="helloBean")
    public HelloWorld helloWorld() {
        return new HelloWorldImpl();
    }
}

App.java

package com.codemonkey;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.codemonkey.interfaces.HelloWorld;
import com.codemonkey.config.AppConfig;

public class App {
    public static void main( String[] args ){
        helloWorld();
    }

    public static void helloWorld(){
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        HelloWorld obj = (HelloWorld) context.getBean("helloBean");
        obj.printHelloWorld("Hola, mundo!!!");
    }
}

Ejecutar:

mvn exec:java -Dexec.mainClass="com.codemonkey.App"

Visto en: http://www.java2s.com/Tutorials/Java/Spring/0035__Spring_3_JavaConfig.htm

Crear proyecto Java con Maven

mug-524103_1920

Generar proyecto.

mvn archetype:generate -DgroupId=com.codemonkey -DartifactId=Inicio -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Ubicarnos en el proyecto.

cd Inicio

Compatibilidad con eclipse.

mvn eclipse:eclipse

Archivos generados.

pom.xml

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.codemonkey</groupId>
  <artifactId>Inicio</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>Inicio</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
    <version>2.5.6</version>
  </dependency>   
  </dependencies>
</project>

App.java


package com.codemonkey;

/**
 * Hola mundo!
 *
 */
public class App {
    public static void main( String[] args ){
        System.out.println( "Hola mundo!" );
    }
}

Compilar.

mvn compile

Ejecutar.

mvn exec:java -Dexec.mainClass="com.codemonkey.App"  

Ejecutar un proyecto Java con Maven y/o Gradle

mug-524103_1920

Maven y Gradle nos facilitan la vida a los desarrolladores. No sólo se encargan de descargar la librerías necesarias para nuestros proyectos, además podemos compilar y poner en marcha nuestras aplicaciones.

build.gradle

apply plugin:'java'
apply plugin:'application'
apply plugin:'project-report'
apply plugin:'eclipse'

//defaultTasks 'build'

sourceCompatibility = '1.8'
version = '0.0.1'
mainClassName= 'com.codemonkey.Main'
description ="""
Ejemplo de proyecto hecho con Gradle build

Codemonkey Junior Blogspot

"""

jar {

baseName='principal'

from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }

manifest{
attributes 'Main-Class': 'com.codemonkey.Main'
}
}

repositories {
mavenCentral()
}

dependencies {
compile group: 'org.projectlombok', name: 'lombok', version: '1.18.2'
}

project.configurations.compile.resolvedConfiguration.resolvedArtifacts.each {
println ' [Dependencias] '
println 'artifact: '+it.name // << the artifact name
println 'referencia: '+it.file // << the file reference
println '**************************'
}

Compilar y ejecutar proyecto Java con Gradle.

$ gradle build

$ gradle run

pom.xml

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.codemonkey</groupId>
    <artifactId>ocajse8</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>ocajse8</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>


<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.2</version>
    <scope>provided</scope>
</dependency>

    </dependencies>

</project>

Compilar y ejecutar proyecto Java con Maven.

$ mvn compile

$ mvn exec:java -Dexec.mainClass=com.codemonkey.Main