Scala IDE

Scala IDE

Ahora que tuve un poco de tiempo de probar varios lenguajes como: Scala, Ceylon, Clojure, etc. encontré este sitio Scala IDE http://scala-ide.org/

Se trata de un IDE (plugin) para crear programas en Scala desde Eclipse.

En Eclipse basta poner este link:

http://download.scala-ide.org/releases-29/stable/site

Y la verdad no pude evitarlo, quise probarlo con un código que hice en Groovy haber como quedaba:

object Horoscopo{

   def main(args: Array[String]){

      var resto=0;

      val anyos=List(1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012);

      var horos=""

      println("[Horoscopo chino en Scala]");

        for(val i <- anyos){

           resto=i%12

          

           if(resto==0){

              horos="mono"

            }

           if(resto==1){

              horos="gallo"

           }

          

           if(resto==2){

              horos="perro"

            }

           if(resto==3){

              horos="cerdo"

           }

           if(resto==4){

              horos="rata"

            }

           if(resto==5){

              horos="buey"

           }

          

           if(resto==6){

              horos="tigre"

            }

           if(resto==7){

              horos="conejo"

           }

           if(resto==8){

              horos="dragon"

           }

           if(resto==9){

              horos="serpiente"

            }

           if(resto==10){

              horos="caballo"

           }

          

           if(resto==11){

              horos="cabra"

            }

          

           println("si naciste en: "+i+" te corresponde el anyo del: "+horos)

          

         }

        

    }

}



Semejanzas con Groovy Python 

Horoscopo.groovy

def anyos=[1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012]
def resto=0
def horos=""
println "\t[Horoscopo chino en Groovy]\n"
for (int e:anyos){
  resto=e%12
  switch(resto){
  case 0:
                horos="mono"
                break
                case 1:
                horos="gallo"
                break
                case 2:
                horos="perro"
                break
                case 3:
                horos="cerdo"
                break
                case 4:
                horos="rata"
                break
                case 5:
                horos="buey"
                break
                case 6:
                horos="tigre"
                break
                case 7:
                horos="conejo"
                break
                case 8:
                horos="dragon"
                break
                case 9:
                horos="serpiente"
                break
                case 10:
                horos="caballo"
                break
                case 11:
                horos="cabra"
                break
  }



  println "Si nacistes en $e  te corresponde el signo: $horos "
}



Horoscopo.py

resto,i=0,0
horos=""
print "\t[Horoscopo chino en Python]\n"
for i in range(len(anyos)):
    resto=anyos[i]%12

    if resto==0:
        horos="mono"

    if resto==1:
        horos="gallo"

    if resto==2:
        horos="perro"

    if resto==3:
        horos="cerdo"

    if resto==4:
        horos="rata"

    if resto==5:
        horos="buey"


    if resto==6:
        horos="tigre"

    if resto==7:
        horos="conejo"

    if resto==8:
        horos="dragon"

    if resto==9:
        horos="serpiente"

    if resto==10:
        horos="caballo"

    if resto==11:
        horos="cabra"

    print "Si naciste en",anyos[i]," te corresponde el signo: ",horos

Ceylon IDE ...

Bueno con la novedad que tuve un poco de tiempo y quise probar el IDE de Ceylon (en Eclipse), pero al parecer tengo un gran problema.

Crear un proyecto Ceylon usando Eclipse

Nombrar el proyecto

Crear un paquete

Crear unidad Ceylon

Aqui surge un problema

No existe la unidad Ceylon. No sé cual sea el problema pero en cuanto logré encontrarlo y hallé la solución seguiré con el post.

Scala… ejemplos sencillos

Variable de entorno

Agregarla al path

Ej 1. Hola mundo

object Hola extends App{

     println("¡Hola mundo, si ves esto ya funciona tu primer programa en Scala!");

  }

Compilar:

scalac Hola.scala

Ejecutar:

scala Hola

Ej 2. Introducir y mostrar datos

//introducir datos y mostrarlos

object Prog01 extends App{

  val nombre=readLine("Escribe tu nombre: ")

println(“”)

  printf("Hola %s",nombre)

  //se puede usar también println("Hola "+nombre)

  println("")

  println("Cuantos anyos tienes: ")

  val edad=readInt()

  println("")

  printf("tienes: %d anyos",edad)

  //se puede usar también println("tienes: "+edad+"anyos")

}

Ej 3. Mostrar variables: enteros, reales, cadenas y caracteres

object Prog02 extends App{

val entero=0; //puedes usar también var si deseas modificar su valor

val real=9.7

val cadena="Esto es una cadena"

val caracter=cadena.charAt(0)

println("entero: "+entero)

printf("entero: %d\n",entero)

println("real: "+real)

printf("real: %f\n",real)

println("cadena: "+cadena)

printf("cadena: %s\n",cadena)

println("caracter: "+caracter)

printf("caracter: %c\n",caracter)

}

Ej 4. Función que muestre la longitud de una cadena

object Prog03 extends App{

def obtenerLongitudMsg(msg: String){

  val ver=msg+"  la longitud es de: "+msg.length

  println(ver)

}

var miMsg="Hola usuario de Scala"

obtenerLongitudMsg(miMsg)

}

Ej 5.  Factorial de un número

object Prog04 extends App{

def obtenerFactorial(x: BigInt): BigInt={

  if(x==0) 1 else x*obtenerFactorial(x-1)

}

var num=5

println("El factorial de "+num+"  es: "+obtenerFactorial(num))

}

Ej 6.  Sumatoria del 1 al 10

object Prog05{

def main(args: Array[String]){

var n=1;

var suma=0;

println("Bucles en Scala");

while(n<=10){

 suma+=n;

 n+=1;

 println("suma: "+suma);

 println("n: "+n);

} 

}

}

Ej 7.  Uso de diccionarios

object Prog10{

   def main(args: Array[String]){

     var diccionario=Map("El Negativo"->"Segun un programador","Jose"->"Psicomantis","Adela"->"Mi hermana","Catalina"->"La gata del hogar");

      println(diccionario("El Negativo"));

      println(diccionario("Jose"));

      println(diccionario("Adela"));

      println(diccionario("Catalina"));

   }

}

Ej 8.  Calcular movimiento

import java.lang.Math;

object Prog11{

  def main(args: Array[String]){

   var mov=0.0;

   var cont=0.0;

   var k2=0.2;

   var dt=0.5;

   var g=9.81;

   while(cont<50){

     cont+=dt;

     mov=Math.sqrt(mov*mov+k2*g*cont);

     println(""+mov+"  -->"+cont);

   }

  }

}

Ej 9.   Sumar caracteres de una cadena numérica

object Prog13{

  def main(args: Array[String]){

    var cadenaNumerica="543";

  

    println("Valor: "+cadenaNumerica+"\n");

    var i=0;

     var suma=0;

    while(i<3) {

        var caracter=cadenaNumerica.charAt(i);

        var cadena=String.valueOf(caracter);

      suma=suma+Integer.parseInt(cadena);

        i+=1;

    }

    println("Suma de los caracteres: "+suma);

    }

}

Ej 10. Clases

object Prog15{

class Persona(nombre: String, edad: Int){

def getNombre()=nombre

def getEdad()=edad

}

def main(args: Array[String]){

   def miObjeto=new Persona("El negativo",30);

   def otroObjeto=new Persona("El Positivo",25);

   println("Mi nombre es: "+miObjeto.getNombre())

   println("tengo: "+miObjeto.getEdad()+" anyos de edad")

   println("Mi nombre es: "+otroObjeto.getNombre())

   println("tengo: "+otroObjeto.getEdad()+" anyos de edad")

}

}

Graven: Crear proyectos con Maven y Gradle

En post anteriores ya había tratado sobre Gradle y Maven

http://codemonkeyjunior.blogspot.com/2012/01/comenzar-un-proyecto-en-gradle.html

http://codemonkeyjunior.blogspot.com/2012/01/maven-crear-proyecto-web-e-importarlo.html

Pero creo faltó hacer un ejemplo más completo.

1. Crear las variables de entorno

2. Agregarlas al path del sistema

%GRADLE_HOME%\bin

%M2_HOME%\bin

3. Comprobar instalación, en la terminal escribir:

gradle  –v

mvn  –v

pom.xml  (Maven) y build.gradle (Gradle)

Son archivos que sirven para describir y administrar las dependencias de nuestros proyectos.

Interfaz gráfica de Gradle

En la terminal o consola de comandos escribir: gradle -gui

Ayuda a probrar tus scripts, algo así como groovyConsole

Un script sencillo con Gradle

En un bloc de notas (notepad u otro) escribir:

//primer script

task Script01 << { println “Si ves esto ya funciona el script”

}

Guardarlo como: build.gradle

Ejecutar en la consola:

gradle build

Si sale un error es porque todavía no hemos agregado nada al proyecto

Crear una tarea simple

task Script01 << { println "Si ves esto ya funciona correctamente"}

Para ejecutar esta tarea simple

gradle –q Script01  

También se puede desde la interfaz gráfica

gradle –gui

Crear proyecto con Maven

Ir al directorio donde se quiere crear el proyecto

mvn archetype:create -DgroupId=org.proyecto.prueba01 -DartifactId=SistemaGraven -DarchetypeArtifactId=maven-archetype-webapp -Dversion=”0.0.1”

Otra forma

mvn archetype:create -DgroupId= org.proyecto.prueba01 -DartifactId=SistemaGraven

Crear el paquete:

mvn  package

Instalar:

mvn install

Agregar  la variable del repositorio local Maven

mvn –Declipse.workspace= “C:\eclipse\Workspace eclipse:add-maven-repo”

En  Eclipse comprobar en Java\Build path\Classpath variables si se ha dado de alta correctamente el repositorio de Maven

Importar el proyecto al Eclipse mediante el menú File\Import...\Existing proyect into Workspace..

Si existe algún error al importar el proyecto puedes entrar al classpath
y reemplazar la etiqueta:

<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER" .....

por:

<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER">
<attributes>
<attribute name="org.eclipse.jst.component.dependency" value="/WEB-INF/lib"/>
</attributes>
</classpathentry>

Editar el fichero pom.xml...

Tal vez la parte más difícil del proyecto.

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

  <modelVersion>4.0.0</modelVersion>

  <groupId>org.proyecto.prueba01</groupId>

  <artifactId>SistemaGraven</artifactId>

  <version>1.0-SNAPSHOT</version>

  <packaging>jar</packaging>

  <name>SistemaGraven</name>

  <url>http://maven.apache.org</url>

  <properties>

    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

  </properties>

  <dependencies>

    <dependency>

      <groupId>junit</groupId>

      <artifactId>junit</artifactId>

      <version>3.8.1</version>

      <scope>test</scope>

    </dependency>

  </dependencies>

</project>

Ahora  con Gradle

Al crear nuestro proyecto (“simple” o web) con Maven debe quedar la estructura de la siguiente manera:

SistemaGraven

src/main/java/prueba01

src/main/resources

src/test/java/prueba01

src/test/resources
pom.xml

Ahora agregar al directorio Sistemas el archivo build.gradle

SistemaGraven

src/main/java/prueba01

src/main/resources

src/test/java/prueba01

src/test/resources
pom.xml

build.gradle

Contenido del  build.gradle

//Esto es para usar el plugin de Gradle para Java

apply plugin:'java'

//Esto es para usar el plugin de Gradle para Eclipse

apply plugin:'eclipse'

//El plugin para Java define un montón de cosas, entre ellas varias tareas

//invocamos aquí la principal para compilar todo por default

defaultTasks 'build'

//En esta sección incluimos los repositorios de Maven

repositories {

  mavenLocal()

  mavenCentral()

}

//Aquí se definen las dependencias para cada configuración.

//Importamos jUnit solamente para la compilacion de pruebas unitarias

dependencies {

  testCompile 'junit:junit:4.+'

}

Desde la terminal escribir:

gradle build

La estructura del proyecto SistemaGraven queda asi:

SistemaGraven

src/main/java/prueba01

src/main/resources

src/test/java/prueba01

src/test/resources

pom.xml

build.gradle

build.gradle

Groovy… programando al estilo Java

Variable de entorno GROOVY_HOME como nombre y el valor la ubicación de la carpeta y agregarla al path del sistema.

Dentro del terminal escribir

GroovyConsole: para escribir, compilar y ejecutar tus programas

Ej. 1 ¿Cómo saber  que una cadena es numérica?

//definir una variable de tipo String

def miNumero=”3451”

static String esNumerico(String cad){

 if(!cad.equals(“”)){

try{

double numerico= Double.parseDouble(“cad”);

}catch(Exception ex){

return “no  numérico”;

}

return “numérico”;

}else{

return “no hay nada que evaluar”;

}

}

//invocar método/función

println(miNumero+”  es: ”+esNumerico(miNumero))

Ej 2. Sumar los caracteres de una cadena numérica

static int sumarCaracteres(String cad){

int suma=0

for(i=0;i<cad.length();i++){

char character=cad.charAt(i);

String cadena= String.valueOf(cararcter);

suma+=Integer.parseInt(cadena);

}

return suma

}

def minumero=”1342”

Ej 3. Introducir datos desde teclado en Groovy

import java.util.Scanner

class Entrada {

   

    static String inicio(){

        String cad="";

        Scanner teclado=new Scanner(System.in);

        try{

            cad=teclado.nextLine();       

        }catch(Exception ex){

            System.err.println("error: "+ex);

        }

        return cad;

    }

   

    static String cadena(){

        String cadena=inicio();

        return cadena;

    }

   

    static int entero(){

        int entero=Integer.parseInt(inicio());

        return entero;

    }

   

    static double real(){

        double real=Double.parseDouble(inicio());

        return real;

    }

   

    static char caracter(){

        String caracter=inicio();

        return caracter.charAt(0);

    }

   

   

    public static void main(String[] args){

    String cadenas=null

    int enteros=9

    char caracteres='e'

    double reales=9.5

    Entrada entrada=new Entrada()

   

   

      println("Introduce entero:")

      enteros=entrada.entero()

     

      println("Introduce real:")

      reales=entrada.real()

      println("Introduce cadena:")

      cadenas=entrada.inicio()

      println("Introduce caracter:")

      caracteres=entrada.caracter()

      

      

       println("Entero: "+enteros)

       println("Real: "+reales)

       println("Cadena: "+cadenas)

       println("Caracter: "+caracteres)

    }

 }

Frameworks… Spring Framework

Es un framework para desarrollo en Java. Su misión es  hacer de la programación Java algo más sencillo de realizar. Es un "contenedor de objetos" (beans) como alternativa a EJB; normalmente usa archivos xml para definir los beans.

Tipos de inyección de dependencias:

1. en las propiedades usando set
2. o directamente usando un constructor
3. en interfaces (no usado)

Además nos permite integrar otras tecnologías (GWT, Hibernate,JSF, etc.). Permite el testeo de las clases (pruebas unitarias, TDD,etc.) y otras cosas más.

1. Este es un ejercicio sencillo: el famoso Hola mundo !!


ServicioHola.java
package org.springpruebas.prueba01;

/**
 *
 * @author yo
 */
public interface ServicioHola {
   public abstract void decirHola();
}

ServicioHolaImpl.java

package org.springpruebas.prueba01;

/**

 *

 * @author yo

 */

public class ServicioHolaImpl implements ServicioHola {

  private String greeting;

  public  ServicioHolaImpl  () {}

  

  public  ServicioHolaImpl  (String saludo) {

    this.saludo = saludo;

  }

  public void decirHola() {

    System.out.println(saludo);

  }

  public void setSaludo(String saludo) {

    this.saludo = saludo;

  }

}

context.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

    "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

  <!-- para el ejemplo de HolaApp.java -->

  <bean id="holaServicio"

      class="org.springpruebas.prueba01.ServicioHolaImpl">

    <property name="saludo">

      <value>Hola mundo!!</value>

    </property>

  </bean>

  <!-- para el ejemplo de HolaApp.java -->

</beans>

HolaApp.java

package org.springpruebas.prueba01;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

 *

 * @author yo

 */

public class HolaApp {

   public static void main(String[] args) throws Exception {

 ApplicationContext  application= new ClassPathXmlApplicationContext("context.xml");

 ServicioHola holaServicio =(ServicioHola) application.getBean("holaServicio");

    holaServicio.decirHola();

  }

}

Salida (en Netbeans):

Hola mundo!!
BUILD SUCCESSFUL (total time: 0 seconds)

http://www.springsource.org/

Frameworks… Google Web Toolkit

Google Web Toolkit

Es un framework que permite crear aplicaciones web similares a aplicaciones de escritorio; posee componentes (controles) muy parecidos a los que tiene Java Swing:

1.       TextBox

2.       ListBox

3.        Image

4.       Tree

5.        Grid

6.       Window

7.        Etc. 

GWT compila el código Java y lo traduce a Javascript y HTML (algo parecido a lo que hace la librería dwr.jar).  

GWT y los IDEs

Creo la mejor forma de usar este framework es con  ayuda de un IDE como NetBeans  y/o Eclipse,  existen plugins para ambos y según yo no son difíciles de configurar.

¿Qué necesito para empezar con GWT?

1.       El SDK GWT

2.       El plugin (para NetBeans o Eclipse)

3.       Librerías gwtext, mejora muchos de los controles de gwt

Ejemplo 1. Un botón que activa una ventana “alert”.

package org.gwtprueba.client;

import com.google.gwt.core.client.EntryPoint;

import com.google.gwt.user.client.Window;

import com.gwtext.client.core.EventObject;

import com.gwtext.client.widgets.Button;

import com.gwtext.client.widgets.event.ButtonListenerAdapter;

/**

 * @author yo

 */

public class testGWTEntryPoint implements EntryPoint {

public void onModuleLoad() {

        Button btnActiva=new Button();

        btnActiva.setText("Activar mensaje");

        btnActiva.addListener(new ButtonListenerAdapter(){

        @Override

         public void onClick(Button btn, EventObject ev){

           Window.alert("Bienvenido usuario");

         }

        });

        RootPanel.get().add(btnActiva);

    }

}

Ejemplo 2. Crear un ejmeplo básico de GWT RPC

Automáticamente se generan  4 archivos java: GWTService.java, GWTServiceAsync.java, GWTServiceImpl.java y GWTServiceUsageExample.java (este es el archivo principal).

GWTService.java

package org.prueba.client;

import com.google.gwt.user.client.rpc.RemoteService;

public interface GWTService extends RemoteService{

    public String myMethod(String s,Integer e);

}

GWTServiceAsync.java

package org.prueba.client;

import com.google.gwt.user.client.rpc.AsyncCallback;

public interface GWTServiceAsync {

    public void myMethod(String s,int e, AsyncCallback callback);

}

GWTServiceImpl.java

package org.prueba.server;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

import org.redalyc.client.GWTService;

public class GWTServiceImpl extends RemoteServiceServlet implements

        GWTService {

   

    public String myMethod(String s,int e) {

        // Do something interesting with 's' here on the server.

        return "Hola: " + s+"   tienes  "+e+"   años";

    }

}

GWTServiceUsageExample.java

package org.prueba.client;

import com.google.gwt.core.client.GWT;

import com.google.gwt.user.client.rpc.AsyncCallback;

import com.google.gwt.user.client.rpc.ServiceDefTarget;

import com.google.gwt.user.client.ui.Button;

import com.google.gwt.user.client.ui.ClickListener;

import com.google.gwt.user.client.ui.Label;

import com.google.gwt.user.client.ui.TextBox;

import com.google.gwt.user.client.ui.VerticalPanel;

import com.google.gwt.user.client.ui.Widget;

public class GWTServiceUsageExample extends VerticalPanel {

    private Label lblServerReply = new Label();

    private TextBox txtNombre= new TextBox();

private TextBox  txtEdad = new TextBox();

    private Button btnSend = new Button("Enviar al servidor");

   

    public GWTServiceUsageExample() {

        add(new Label("Introduce tu nombre: "));

        add(txtNombre);

        add(new Label("Introduce tu edad: "));

        add(txtEdad);

        add(btnSend);

        add(lblServerReply);

       

        // Create an asynchronous callback to handle the result.

        final AsyncCallback callback = new AsyncCallback() {

            public void onSuccess(Object result) {

                lblServerReply.setText((String)result);

            }

           

            public void onFailure(Throwable caught) {

                lblServerReply.setText("Communicación fallida");

            }

        };

       

        // Listen for the button clicks

        btnSend.addClickListener(new ClickListener(){

            public void onClick(Widget w) {

                // Make remote call. Control flow will continue immediately and later

                // 'callback' will be invoked when the RPC completes.

                getService().myMethod(txtNombre.getText(),Integer.parseInt(txtEdad.getText()), callback);

            }

        });

    }

   

    public static GWTServiceAsync getService(){

        // Create the client proxy. Note that although you are creating the

        // service interface proper, you cast the result to the asynchronous

        // version of

        // the interface. The cast is always safe because the generated proxy

        // implements the asynchronous interface automatically.

        GWTServiceAsync service = (GWTServiceAsync) GWT.create(GWTService.class);

        // Specify the URL at which our service implementation is running.

        // Note that the target URL must reside on the same domain and port from

        // which the host page was served.

        //

        ServiceDefTarget endpoint = (ServiceDefTarget) service;

        String moduleRelativeURL = GWT.getModuleBaseURL() + "gwtservice";

        endpoint.setServiceEntryPoint(moduleRelativeURL);

        return service;

    }

}

Ahora falta crear la clase que lo muestre

package org.prueba.client;

import com.google.gwt.core.client.EntryPoint;

import com.google.gwt.user.client.ui.RootPanel;

public class Prog01  implements EntryPoint {

    public void onModuleLoad() {

        RootPanel.get().add(new GWTServiceUsageExample());

    }

}

36 Guías GWT
http://pathfindersoftware.com/2007/07/36-gwt-tutorial/

Página oficial, plugin para Eclipse

http://code.google.com/intl/es-419/webtoolkit/download.html

Plugin para NetBeans

http://plugins.netbeans.org/plugin/716/gwt4nb

http://java.net/projects/gwt4nb/pages/Home

http://java.net/projects/gwt4nb/downloads

Blog oficial GWT

http://googlewebtoolkit.blogspot.com/

SmartGWT

http://code.google.com/p/smartgwt/

Demo GWT ext

http://www.gwt-ext.com/demo

Manual  GWT

http://google-web-toolkit.googlecode.com/svn/javadoc/1.6/com/google/gwt/user/client/ui/

http://google-web-toolkit.googlecode.com/svn/javadoc/1.6/com/google/

Manual GWT ext

http://gwt-ext.com/docs/2.0.4/com/gwtext/

http://www.java2s.com/Code/Java/GWT/CatalogGWT.htm

Libros

http://stackoverflow.com/questions/194812/list-of-freely-available-programming-books

http://blog-erone.blogspot.com/2009/07/montar-gwt-ext-en-netbeans.html

Blogs sobre GWT
http://desarrollo-web-gwt.blogspot.com/

http://unpocodejava.wordpress.com/2012/01/12/un-poco-de-gwt/
http://www.ajaxline.com/20-best-gwt-tutorials-and-articles

Wiki
http://wikis.uca.es/wikiii/index.php/Google_Web_Toolkit_(GWT)