lunes, 22 de julio de 2013

Identificadores en Java


Comenzaremos con identificadores, pero ¿Qué es un identificador?.

En el desarrollo de una aplicación java nosotros nos veremos en la necesidad de declarar clases, métodos, atributos , variables locales, enumeraciones y un montón de cosas para que nuestro programa funcione de manera eficiente.

 Cuando la mayoría de nosotros comenzamos a programar trabajábamos siempre con nuestras variables "x" y "y", pero ¿Podemos usar nombres diferentes en nuestros programas?, pues claro que si!!!. Siempre y cuando cumplamos con algunas reglas que determinan que nombre es legal dentro de una aplicación java así que vamos a verlas:

Identificadores legales :

1.-Los identificadores legales dentro de un programa en java deben comenzar forzosamente con una letra, un signo de "$" ó un "_".

2.-Después del primer carácter nosotros podemos combinar el nombre con tanto letras como con números.

3.- No hay un número limite de caracteres de un identificador así que nosotros podremos escribir nombres de variables tan largos como queramos.

4.- No pueden contener espacios.

5.- No pueden pertenecer a las palabras reservadas en el lenguaje.

La declaración de identificadores debe cumplir con la siguiente expresión regular


  [\w$_]([\w\d$_]*).  

Veamos un ejemplo :

 public class _ {  
   public void $(int _$){  
     System.out.println(_$);  
   }  
   public static void main(String[] args) {  
      int $9=800;  
      int $h=$9;  
      new _().$($h);  
   }  
 }  


Mencionado lo anterior les preguntare ¿El programa compilará o no?.

La respuesta es : si el programa compila sin ningún problema y dará la siguiente salida:

800

Vamos a analizar linea a linea el código:

Comentamos que los identificadores podían comenzar con un guion bajo, no hay ninguna regla que diga que no pueden tener solo un dígito.

 public class _ {  

El nombre del método es $ símbolo con el cual puede comenzar cualquier identificador y recibe como argumento una variable de tipo entero llamada _$ la cual cumple con las reglas mencionadas anteriormente:


  public void $(int _$){  
     System.out.println(_$);  
   }  

Los identificadores no pueden comenzar por números, pero a partir del segundo carácter podrán tener tanto números como letras

   public static void main(String[] args) {  
      int $9=800;  
      int $h=$9;  

Esta linea puede ser un poco confusa pero vamos a revisarla. Como vemos estamos creando un objeto de la clase guion bajo y no guardamos la referencia, solo estamos utilizando el objeto creado para acceder al método "$" y le estamos pasando como argumento la variable $h.

 new _().$($h);  
   }  
 }  

Se que cuando desarrollamos aplicaciones no utilizamos nombres tan confusos pero recuerden si quieren presentar el examen OCJP es muy importante que dominen a la perfección el lenguaje,hasta el momento solo hemos visto identificadores que cumplen perfectamente bien con las reglas, pero no hemos visto identificadores inválidos, veamos algunos ejemplos:

 float 1_;  
 int @lex;  
 double algo#;  
 int :);  
 int long;  

Por último veamos las palabras reservadas del lenguaje java para no cometer el error de utilizarlas en la declaración de algún identificador, más adelante daré una explicación detallada de estas:

 abstract default if     private    this  
 boolean  do    implements protected   throw  
 break   double  import   public    throws  
 byte   else   instanceof return    transient  
 case   extends int     short     try  
 catch   final  interface  static    void  
 char   finally long    strictfp   volatile  
 class   float  native   super     while  
 const   for   new     switch  
 continue goto   package   synchronized  

Si tienen dudas o comentarios no duden en escribir en la sección de comentarios :)


--------->>>>>>>Autor: Alejandro Agapito Bautista
--------->>>>>>>>>>>>Oracle Certified Java Programer
--------->>>>>>>>>>>>Oracle Certified Web Components Developer
--------->>>>>>>>>>>>IBM Certified Academic Assosiate DB2.
--------->>>>>>>Twitter: @raidentrance
--------->>>>>>>Contacto:raidentrance@gmail.com









Cliente Rest con Spring en español !



El diseño de arquitecturas basadas en Web Services es una tarea cada vez más común en el desarrollo de software, Spring Framework provee una forma sencilla forma de consumirlos a través de una clase llamada RestTemplate, esta clase es muy similar a otras como JdbcTemplate, JmsTemplate y a muchos otros Templates que podemos encontrar dentro de Spring Framework.

RestTemplate nos brinda soporte para los siguientes métodos del protocolo HTTP.
  • DELETE
  • GET
  • HEAD
  • OPTIONS
  • POST
  • PUT
Para nuestro ejemplo vamos a consumir un servicio Rest de Facebook haciendo uso del RestTemplate de Spring.

Lo primero que tenemos que hacer es crear un proyecto nuevo haciendo click en el icono "New Project".


Vamos a seleccionar la opción "Maven->Java Application" y hacemos click en "Next".


Seleccionamos un nombre del proyecto en mi caso será "EjemploRestTemplate", un group id para mi caso será "mx.com.geeksjava" y hacemos click en "Finish".



Con esto crearemos un proyecto vacío con la estructura de un proyecto Maven.


Una vez creado el proyecto lo que vamos a hacer es definir cuales son las dependencias(bibliotecas) de nuestro proyecto, para hacer esto vamos a modificar nuestro archivo de configuración "pom.xml", de tal modo que quede de la siguiente forma:

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>mx.com.geeksjava</groupId>  
   <artifactId>EjemploRestTemplate</artifactId>  
   <version>1.0-SNAPSHOT</version>  
   <packaging>jar</packaging>  
   <name>EjemploRestTemplate</name>  
   <url>http://maven.apache.org</url>  
   <properties>  
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
   </properties>  
   <dependencies>  
     <dependency>  
       <groupId>org.springframework</groupId>  
       <artifactId>spring-core</artifactId>  
       <version>3.1.2.RELEASE</version>  
     </dependency>  
     <dependency>  
       <groupId>org.springframework</groupId>  
       <artifactId>spring-test</artifactId>  
       <version>3.1.2.RELEASE</version>  
     </dependency>  
     <dependency>  
       <groupId>org.springframework</groupId>  
       <artifactId>spring-web</artifactId>  
       <version>3.1.2.RELEASE</version>  
     </dependency>  
     <dependency>  
       <groupId>org.apache.httpcomponents</groupId>  
       <artifactId>httpclient</artifactId>  
       <version>4.2-alpha1</version>  
     </dependency>  
     <dependency>  
       <groupId>org.codehaus.jackson</groupId>  
       <artifactId>jackson-mapper-asl</artifactId>  
       <version>1.9.12</version>  
     </dependency>  
     <dependency>  
       <groupId>junit</groupId>  
       <artifactId>junit</artifactId>  
       <version>4.7</version>  
       <scope>test</scope>  
     </dependency>  
   </dependencies>  
 </project>  


Ahora damos click secundario en nuestro proyecto y seleccionamos la opción "Build with Dependencies" con esto se van a descargar las dependencias necesarias para nuestro proyecto, si es la primera vez que utilizan Maven esto puede tardar algo de tiempo.





Dentro de "Source Packages" vamos a crear un paquete llamado "mx.com.geeksjava.ejemploresttemplate.client" y dentro de la carpeta "Other Sources" vamos a crear un archivo xml al que nombraremos "restApplicationContext.xml".

restApplicationContext.xml

 <?xml version="1.0" encoding="UTF-8"?>  
 <beans xmlns="http://www.springframework.org/schema/beans"  
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">  
   <context:component-scan base-package="mx.com.geeksjava.ejemploresttemplate.client"></context:component-scan>  
   <bean id="requestFactory" class="org.springframework.http.client.HttpComponentsClientHttpRequestFactory">  
     <constructor-arg ref="httpClient" />  
   </bean>  
   <bean id="restTemplate" class="org.springframework.web.client.RestTemplate">  
     <constructor-arg>  
       <ref bean="requestFactory" />  
     </constructor-arg>  
   </bean>  
   <bean id="httpClient" class="org.apache.http.impl.client.DefaultHttpClient">  
     <constructor-arg>  
       <bean class="org.apache.http.impl.conn.PoolingClientConnectionManager"/>  
     </constructor-arg>  
   </bean>  
 </beans>  

Con esto vamos a configurar el RestTemplate, lo que resta ya simplemente es utilizarlo y probar su funcionamiento, para esto vamos a crear una clase llamada "ClienteFacebook" dentro del paquete "mx.com.geeksjava.ejemploresttemplate.client.



 package mx.com.geeksjava.ejemploresttemplate.client;  
 import java.util.HashMap;  
 import java.util.Map;  
 import java.util.logging.Logger;  
 import org.springframework.beans.factory.annotation.Autowired;  
 import org.springframework.stereotype.Service;  
 import org.springframework.web.client.RestTemplate;  
 @Service("clienteFacebook")  
 public class ClienteFacebook {  
   @Autowired  
   private RestTemplate restTemplate;  
   private static final String URL = "https://graph.facebook.com/search?q={query}&access_token={token}";  
   private static final Logger LOG = Logger.getLogger(ClienteFacebook.class.getName());  
   public void muestraTweets(String q) {  
     Map<String, String> vars = new HashMap<String, String>();  
     vars.put("query", q);  
     vars.put("token", "INSERTAR AQUI SU TOKEN DE FACEBOOK :)  ");  
     String res = restTemplate.getForObject(URL, String.class, vars);  
     LOG.info(res);  
   }  
 }  

En esta clase lo que hacemos es inyectar el RestTemplate de Spring que ya configuramos, definir nuestra URL a la cual vamos a hacer la petición Rest y crear la petición que se va a realizar, en este caso es una petición de tipo "GET" por eso utilizamos el método "getForObject" le pasamos la URL el tipo de dato que queremos que nos devuelva y las variables que se requieren para hacer la petición. Existen algunos puntos importantes en el código anterior.

En la línea:

     vars.put("token", "INSERTAR AQUI SU TOKEN DE FACEBOOK :)  ");  


 Se debe sustituir el texto INSERTAR AQUI SU TOKEN DE FACEBOOK :)   por un token válido de facebook, dicho token lo vamos a obtener entrando a la dirección https://developers.facebook.com/tools/explorer?method=GET&path=100000436331886%3Ffields%3Did%2Cname y de la siguiente forma:


Otro aspecto a considerar en esta clase es en la línea

     String res = restTemplate.getForObject(URL, String.class, vars);  

El método getForObject recibe 3 parámetros:

  1. Url: Representa la URL a la cual se va a realizar la petición HTTP.
  2. Response type: Representa a que queremos que se transforme esa respuesta, nosotros podríamos crear una clase llamada PostFacebook y tranformar la respuesta a esa clase, en nuestro caso solo la transformamos a String de tal modo que la variable "res" contendrá el texto de la respuesta en formato JSON.
  3. urlVariables: Variables para agregar a la url como pueden ver la URL se definió de la siguiente forma https://graph.facebook.com/search?q={query}&access_token={token} de tal modo que las palabras query y token son dos variables, estas variables serán reemplazadas por urlVariables, por esto se manda como argumento un mapa en el cual la llave es el nombre de la variable y el valor es el valor que tomará la viariable.


Una vez creado nuestro ClienteFacebook vamos a crear una prueba unitaria utilizando JUnit para validar que realmente se este haciendo la petición a Facebook y se nos muestre el resultado de dicha petición en nuestra consola.

Para esto vamos a crear la clase "ClienteFacebookTest" en la carpeta "Test Packages":

 package mx.com.geeksjava.ejemploresttemplate;  
 import mx.com.geeksjava.ejemploresttemplate.client.ClienteFacebook;  
 import org.junit.Test;  
 import org.junit.runner.RunWith;  
 import org.springframework.beans.factory.annotation.Autowired;  
 import org.springframework.test.context.ContextConfiguration;  
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
 @RunWith(SpringJUnit4ClassRunner.class)  
 @ContextConfiguration("/restApplicationContext.xml")  
 public class ClienteFacebookTest {  
   @Autowired  
   private ClienteFacebook clienteFacebook;  
   @Test  
   public void testMuestraTweets() {  
     clienteFacebook.muestraTweets("Ommix");  
   }  
 }  



Hacemos click secundario en la clase "ClienteFacebookTest" y damos click en "Test File".



Como podemos ver el test unitario fue exitoso y ahora vamos a hacer click en la pestaña "Output" y buscar el info donde imprimimos el resultado en la consola.




Y con esto consumimos un servicio rest que en este caso fue es Graph Api de facebook y lo mostramos en nuestra aplicación, como pueden ver nosotros no tuvimos que crear un cliente HTTP ni abrir ningún flujo ni nada por el estilo, solo creamos nuestro RestClient y el se encargó de las tareas engorrosas de consumir un servicio rest.


Pueden descargar el código fuente en EjemploRestTemplate.rar  dudas, sugerencias de furutos post's dejen un comentario :).

--------->>>>>>>Autor: Alejandro Agapito Bautista
--------->>>>>>>>>>>>Oracle Certified Java Programer
--------->>>>>>>>>>>>Oracle Certified Web Components Developer
--------->>>>>>>>>>>>IBM Certified Academic Assosiate DB2.
--------->>>>>>>Twitter: @raidentrance
--------->>>>>>>Contacto:raidentrance@gmail.com