sábado, 28 de enero de 2012

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)

sábado, 21 de enero de 2012

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());
    }

}


Página oficial, plugin para Eclipse

Plugin para NetBeans

Blog oficial GWT

SmartGWT

Demo GWT ext


Manual  GWT

Manual GWT ext

Libros

Programando en Java... errores comunes




1. The Maven Integration requires that Eclipse be running in a JDK.

Muchas veces el al instalar el plugin de Maven para Eclipse sale una ventana con este mensaje y es bastante molesto.  Parece que Maven no reconoce la ruta del JDK y tendremos que agregarla manualmente.

Solución:
  1. Abrir el archivo eclipse.ini
  2. Agregar la siguiente línea (aqui pongo el ejemplo para Windows): 
-vm
C:\Java\jdk1.7.0\bin\javaw.exe

Listo, problema resuelto (curioso solo en Windows me ha pasado esto).

2. Error al colocar la ruta de instalación del jdk


Al instalar Java nos pide una ruta, la ruta adecuada para la instalación en Windows es en C:\
Ejemplo
JAVA_HOME, el nombre de la variable
C:\Java\jdkxx , que será el valor


Ahora agregarla al path del sistema %JAVA_HOME%\bin

Listo solo falta ir a la consola de comandos (MS-DOS) y teclear java -version y comprobar que funciona correctamente.

3. Tratar de compilar/ejecutar una clase sin el main

public class Datos{
  private int no_cta;
  private double saldo;


  public Datos(int no_cta,double saldo){
   this.no_cta=no_cta;
   this.saldo=saldo;
  }


 public int getSaldo(){return this.saldo;}
 public int getNo-cat(){return this.no_cta;}


}


Compilar:
javac -g Datos.java

Correcto no parece haber algún error, pero si se trata de ejecutar con: java Datos la línea de comandos tira un error, es porque no encuentra la función  main.


4. Crear un objeto  null 

Muchas veces creamos un objeto y se nos olvida instanciarlo, ejemplo:

private ClaseSecundaria objetoSecundario;


objetoSecundario.setNombre(txtNombre.getText());

Cuando lo correcto sería:

private ClaseSecundaria objetoSecundario;


//aqui coloco la instancia
objetoSecundario= new ClaseSecundaria();
objetoSecundario.setNombre(txtNombre.getText());













domingo, 15 de enero de 2012

Java básico ... variables de entorno y la path

1. Crear la variable de entorno

2. Agregar la ruta

Ejercicios para empezar


Ej1. Imprimir tu nombre  (o varios nombres)  desde la terminal
public class Prog01{
   public static void main(String ... args){
   if(args.length!=0){
     for(String e:args){
        System.out.println("Hola: "+e);
      }
     }else{System.out.println("no hay argumentos");}

   }

}
Compilar:
javac  –g Prog01.java
Ejecutar:
java  Prog01 Unnombre  OtroNombre
Salida:
Hola: Unnombre
Hola: OtroNombre

Ej2.  Sumar, restar, multiplicar y dividir dos números desde terminal
public class Prog02{
   public static void main(String ... args){
           if(args.length!=0){
            double a=Double.parseDouble(args[0]);
            double b=Double.parseDouble(args[1]);
            System.out.println("Números introducidos "+a+" y "+b);
            System.out.println("Suma: "+(a+b));
            System.out.println("Resta: "+(a-b));
            System.out.println("Multiplicacion: "+(a*b));
            System.out.println("Division: "+(a/b));
        }else{
          System.out.println("no hay argumentos");
        }
   }

}
Compilar:
javac  –g Prog02.java
Ejecutar:
java   Prog02 54  32
Salida:
Números introducidos 54 y 32
Suma: 86
Resta: 22
Multiplicacion: 1728
Division: 1.6875




jueves, 12 de enero de 2012

Maven: crear proyecto web e importarlo a Eclipse

Crear un proyecto con Maven es bastante complicado, aunque existen alternativas como Gradle que nos lo facilitan, sigue siendo  el más utilizado.
1.  Ir al directorio donde queremos crear el proyecto:
//en Windows
C:\Users\Alguien\workspace
//en Linux
/home/Alguien/workspace
2.  Desde la terminal crear el proyecto
mvn archetype:create -DgroupId=org.maven.screencast02 -DartifactId=Proyecto02 -
DarchetypeArtifactId=maven-archetype-webapp
3. Empaquetar
mvn package
4. Ahora instalar
mvn install
5. Añadimos la variable del Repositorio local Maven
//Windows
mvn –Declipse.workspace= c:\eclipse\Workspace eclipse:add-maven-repo
//Linux
mvn –Declipse.workspace= home/eclipse/Workspace eclipse:add-maven-repo

6. En el Eclipse comprobamos en Java\Build path\Classpath variables si se ha dado de alta correctamente el repositorio de Maven (ver paso 9)
7. Añadimos el modulo al eclipse de la siguiente manera:
mvn -Dwtpversion=1.5 eclipse:eclipse
8. Importamos el proyecto al eclipse mediante el menú File\Import...\Existing proyect into
Workspace...

9. Si tienes algún error al importar el proyecto puedes entra al classpath
y reemplaza la etiqueta:


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>

Nota: el paso 9 viene de la siguiente liga

10. Editar el fichero pom.xml...

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

miércoles, 11 de enero de 2012

Comenzar un proyecto en Gradle

Visto en

Construcción de Proyectos con Gradle


Ver también:  http://swgu.ru/p7FZiD

 1. Descargar la última versión http://gradle.org/downloads

2. Descomprimir  (Windows) en:
 C:\gradle-1.0-milestone-7
3. Descomprimir  (Linux) en:
home/Usuario/ gradle-1.0-milestone-7
4. Crear la variable de entrorno (Windows)
Nombre: GRADLE_HOME
Valor: C:\gradle-1.0-milestone-7
4.1Agregarla al path, sin el “;”
%GRADLE_HOME%\bin
4.2Crear la variable de entrorno y agregarla al path (Linux)
GRADLE_HOME=/usr/java/gradle-1.0-milestone-7
export GRADLE_HOME
PATH=$PATH:$GRADLE_HOME/bin
export PATH


5.Comprobar si se instalo correctamente (desde la consola de comandos):
gradle -v
6.Crear un proyecto Java con la siguiente estructura de directorios (carpetas):
screencast01
build.gradle
src/main/java
src/main/resources
src/test/java
src/test/resources

6.1Ruta (Windows y/o Linux):
C:\Users\Alguien\Documents\screencast02
Home/Alguien/Documentos/ screencast02
7.Crear el build.gradle (en un bloc de notas), el script debe ir directamente bajo el directorio screencast02,  y colocar estas líneas:
//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.+'
}

8.Crear la clase java Hola.java en  src/main/java/ejemplo
package ejemplo;

public class Hola{

  public String saluda(String quien) {

    return String.format("Hola, %s! (en Java)", quien);

  }

}
9.Crear la prueba unitaria TestAll.java

package ejemplo;
import org.junit.*;
public class TestAll {
  @Test public void testSaludo() {
    Hola o = new Hola();
    assert "Hola, Mundo! (en Java)".equals(o.saluda("Mundo"));
  }
}

10.Ejecutar el script (debemos posicionarnos en el directorio) con:
gradle build

 
En caso de aparecer un error como este 




 

Si sale error poner:
gradle –info
gradle –debug
gradle –stacktrace


Si no hubo problema alguno debe aparecer esto:






 Además se puede usar la interfza gráfica de Gradle para ver  y ejecutar los scripts 


gradle -gui


Debe aparecer esto:
Listo primer proyecto usando Gradle