lunes, 29 de julio de 2013

JavaServer Faces y PrimeFaces utilizando Maven y NetBeans parte 2




A continuación vamos a crear un pequeño sitio que muestre las bondades de utilizar JavaServer Faces utilizando como complemento PrimeFaces, para hacer esto tomaré como base el siguiente post JavaServer Faces y Primefaces utilizando Maven y Netbeans. Una vez configurado JavaServer Faces y Primefaces realizaremos lo siguiente:

Dentro de la carpeta "Source Packages" crearemos un paquete llamado "mx.com.geeksjava.ejemplojsfpt2.model" dentro de este paquete crearemos la clase "Persona".

 package mx.com.geeksjava.ejemplojsfpt2.model;  
 import java.io.Serializable;  
 public class Persona implements Serializable{  
   private String nombre;  
   private String apellidoPaterno;  
   private String apellidoMaterno;  
   private Integer edad;  
   private Character sexo;  
   private String rfc;  
   public Persona() {  
   }  
   public Persona(String nombre, String apellidoPaterno, String apellidoMaterno, Integer edad, Character sexo, String rfc) {  
     this.nombre = nombre;  
     this.apellidoPaterno = apellidoPaterno;  
     this.apellidoMaterno = apellidoMaterno;  
     this.edad = edad;  
     this.sexo = sexo;  
     this.rfc = rfc;  
   }  
   public String getNombre() {  
     return nombre;  
   }  
   public void setNombre(String nombre) {  
     this.nombre = nombre;  
   }  
   public String getApellidoPaterno() {  
     return apellidoPaterno;  
   }  
   public void setApellidoPaterno(String apellidoPaterno) {  
     this.apellidoPaterno = apellidoPaterno;  
   }  
   public String getApellidoMaterno() {  
     return apellidoMaterno;  
   }  
   public void setApellidoMaterno(String apellidoMaterno) {  
     this.apellidoMaterno = apellidoMaterno;  
   }  
   public Integer getEdad() {  
     return edad;  
   }  
   public void setEdad(Integer edad) {  
     this.edad = edad;  
   }  
   public Character getSexo() {  
     return sexo;  
   }  
   public void setSexo(Character sexo) {  
     this.sexo = sexo;  
   }  
   public String getRfc() {  
     return rfc;  
   }  
   public void setRfc(String rfc) {  
     this.rfc = rfc;  
   }  
 }  

Ahora vamos a crear otro paquete dentro de "Source Packages" llamado "mx.com.geeksjava.ejemplojsfpt2.controller", dentro de este paquete vamos a hacer "click secundario -> New->Other->JavaServer Faces->JSF Managed Bean".


Hacemos click en "Next" en el campo "Class Name" colocamos "PersonaController" y en el campo "Scope" seleccionaremos "session".


Esto nos va a generar el código base para un controlador, este código lo modificaremos de tal modo que quede de la siguiente forma:


 package mx.com.geeksjava.ejemplojsfpt2.controller;  
 import java.io.Serializable;  
 import java.util.ArrayList;  
 import java.util.List;  
 import javax.annotation.PostConstruct;  
 import javax.faces.bean.ManagedBean;  
 import javax.faces.bean.SessionScoped;  
 import mx.com.geeksjava.ejemplojsfpt2.model.Persona;  
 @ManagedBean  
 @SessionScoped  
 public class PersonaController implements Serializable {  
   private List<Persona> personas;  
   private Persona persona;  
   @PostConstruct  
   public void inicializa(){  
     personas=new ArrayList<Persona>();  
     persona=new Persona();  
   }  
   public String guardar(){  
     personas.add(persona);  
     persona=new Persona();  
     return "index.faces";  
   }  
   public List<Persona> getPersonas() {  
     return personas;  
   }  
   public void setPersonas(List<Persona> personas) {  
     this.personas = personas;  
   }  
   public Persona getPersona() {  
     return persona;  
   }  
   public void setPersona(Persona persona) {  
     this.persona = persona;  
   }  
 }  

Nos dirigimos a la sección "Web Pages" hacemos "click secundario->New-Other-JavaServer Faces->Facelets Template" y hacemos click en "Next".


En el campo "File Name" colocamos "template-base", en "Folder" colocamos "resources", seleccionamos el "Layout Style" que se muestra en la imagen y hacemos click en "Finish".


Modificamos "template-base.xhtml".

 <?xml version='1.0' encoding='UTF-8' ?>   
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
 <html xmlns="http://www.w3.org/1999/xhtml"  
    xmlns:ui="http://java.sun.com/jsf/facelets"  
    xmlns:h="http://java.sun.com/jsf/html">  
   <h:head>  
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />  
     <h:outputStylesheet library="css" name="default.css"/>  
     <h:outputStylesheet library="css" name="cssLayout.css"/>  
      <title>Geeks Java México</title>  
   </h:head>  
   <h:body>  
     <div id="top" class="top">  
       <ui:insert name="top">Geeks Java México!</ui:insert>  
     </div>  
     <div>  
       <div id="left">  
         <ui:insert name="left">  
           <h:link outcome="index.faces" value="Inicio"/>            
         </ui:insert>  
       </div>  
       <div id="content" class="left_content">  
         <ui:insert name="content"></ui:insert>  
       </div>  
     </div>  
   </h:body>  
 </html>  


Con esto tendremos una plantilla para trabajar, esta plantilla puede ser aplicada para múltiples páginas de tal modo que no tengamos que reescribir el estilo que deseamos en el sistema. Una vez hecho esto hacemos "Click secundario en Web Pages->New->Other->JavaServer Faces->Facelets Template Client" y damos click en "Next".

Colocamos los siguientes campos "File Name = index" y en "Template" seleccionamos "Browse", seleccionamos "template-base.xhtml", hacemos click en "Select File" y presionamos "Finish".



Modificamos el archivo "index.xhtml".

 <?xml version='1.0' encoding='UTF-8' ?>  
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
 <html xmlns="http://www.w3.org/1999/xhtml"  
    xmlns:ui="http://java.sun.com/jsf/facelets"  
    xmlns:h="http://java.sun.com/jsf/html"  
    xmlns:p="http://primefaces.org/ui"  
    xmlns:f="http://java.sun.com/jsf/core">  
   <body>  
     <ui:composition template="./resources/template-base.xhtml">  
       <ui:define name="content">  
         <h:form>  <h1>Personas</h1><br/>
           <p:panelGrid columns="3">  
             <h:outputText value="Nombre"/>  
             <p:inputText id="nombre_p" required="true" value="#{personaController.persona.nombre}"/>  
             <p:message for="nombre_p"/>  
             <h:outputText value="Apellido Paterno"/>  
             <p:inputText id="appat_p" required="true" value="#{personaController.persona.apellidoPaterno}"/>  
             <p:message for="appat_p"/>  
             <h:outputText value="Apellido Materno"/>  
             <p:inputText id="apmat_p" value="#{personaController.persona.apellidoMaterno}"/>  
             <p:message for="apmat_p"/>  
             <h:outputText value="RFC"/>  
             <p:inputText id="rfc_p" required="true" maxlength="13" value="#{personaController.persona.rfc}"/>  
             <p:message for="rfc_p"/>  
             <h:outputText value="Edad"/>  
             <p:inputText id="edad_p" value="#{personaController.persona.edad}"/>  
             <p:message for="nombre_p"/>  
             <h:outputText value="Sexo"/>  
             <p:selectOneRadio id="sexo_p" required="true" value="#{personaController.persona.sexo}">  
               <f:selectItem itemLabel="Masculino" itemValue="m"/>  
               <f:selectItem itemLabel="Femenino" itemValue="f"/>  
             </p:selectOneRadio>  
             <p:message for="sexo_p"/>  
             <p:commandButton action="#{personaController.guardar()}" ajax="false" value="Guardar"/>  
           </p:panelGrid>  
         </h:form>  <br/>
         <p:dataTable id="tabla_personas" value="#{personaController.personas}" var="_persona" rowKey="#{_persona.rfc}"  
                paginator="true" rows="5">  
           <f:facet name="header">  
             <h:outputText value="Personas"/>  
           </f:facet>  
           <p:column headerText="Nombre Completo">  
             <h:outputText value="#{_persona.nombre} #{_persona.apellidoPaterno} #{_persona.apellidoMaterno}"/>  
           </p:column>  
           <p:column headerText="RFC">  
             <h:outputText value="#{_persona.rfc}"/>  
           </p:column>  
           <p:column headerText="Edad">  
             <h:outputText value="#{_persona.edad}"/>  
           </p:column>  
           <p:column headerText="Sexo">  
             <h:outputText value="#{_persona.sexo}"/>  
           </p:column>  
         </p:dataTable>  
       </ui:define>  
     </ui:composition>  
   </body>  
 </html>  

Hacemos click secundario en el nombre del proyecto y seleccionamos "Run".


Esperamos a que se despliegue la aplicación en nuestro navegador por defecto y el resultado.


Como pueden ver Si hacemos click en el botón "Guardar" y no llenamos de forma adecuada los campos aparecerán mensajes para realizarnos la notificación (Estos mensajes pueden ser modificados), podemos ver que tenemos una tabla de datos con paginación de 5 en 5 controlada por PrimeFaces (Es posible utilizar carga floja para la información) todo esto sin necesidad de utilizar JavaScript para realizar validaciones ni paginación.

El uso de JavaServer Faces es muy poderoso para la capa de presentación, más adelante presentaremos un Post en el cuál se detalle como combinar esto con Spring y Spring Data para almacenar la información.

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

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


viernes, 19 de julio de 2013

Spring Data en español



El acceso a bases de datos es una de las tareas más comunes en el desarrollo de software, al principio esta tarea se realizaba simplemente haciendo uso de JDBC (Java Database Connectivity) y poco a poco fue evolucionando utilizando patrones de diseño como el DAO (Data Access Object) y a través de frameworks y API's tales como Hibernate y JPA, estos ORM (Object Relational Mapping) nos han ayudado a reducir muchas de las tareas que se hacían antes con JDBC.

Spring Data es un módulo de Spring que vamos a utilizar sobre JPA para hacer las tareas de acceso a base de datos aún más sencillas, las ventajas se notarán a simple vista ya que nosotros simplemente crearemos métodos en una interfaz y Spring Data se encargará de hacer las implementaciones por nosotros de tal modo que si nombramos un método como "findByName" Spring Data creará la implementación necesaria para buscar en la base de datos a través del nombre sin que nosotros creemos ni una sola conexión ni procesemos ningún resultado.

Spring Data es como el aire acondicionado, una vez que lo utilicen no podrán vivir sin el.

Lo primero que vamos a hacer es crear un proyecto dentro de nuestro entorno de desarrollo.



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


Seleccionamos un nombre del proyecto en mi caso será "EjemploSpringData", 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", dentro de este archivo vamos a agregar las siguientes dependencias dentro de la etiqueta <dependencies></dependencies>.

 <dependencies>  
     <dependency>  
       <groupId>junit</groupId>  
       <artifactId>junit</artifactId>  
       <version>4.7</version>  
       <scope>test</scope>  
     </dependency>  
     <dependency>  
       <groupId>org.springframework</groupId>  
       <artifactId>spring-orm</artifactId>  
       <version>${spring.version}</version>  
     </dependency>  
     <dependency>  
       <groupId>org.springframework</groupId>  
       <artifactId>spring-test</artifactId>  
       <version>${spring.version}</version>  
     </dependency>  
     <dependency>  
       <groupId>commons-dbcp</groupId>  
       <artifactId>commons-dbcp</artifactId>  
       <version>1.4</version>  
     </dependency>  
     <dependency>  
       <groupId>mysql</groupId>  
       <artifactId>mysql-connector-java</artifactId>  
       <version>5.1.17</version>  
     </dependency>  
     <dependency>  
       <groupId>org.hibernate</groupId>  
       <artifactId>hibernate-core</artifactId>  
       <version>3.6.10.Final</version>  
     </dependency>  
     <dependency>  
       <groupId>javassist</groupId>  
       <artifactId>javassist</artifactId>  
       <version>3.8.0.GA</version>  
     </dependency>  
     <dependency>  
       <groupId>org.springframework.data</groupId>  
       <artifactId>spring-data-jpa</artifactId>  
       <version>1.3.2.RELEASE</version>  
     </dependency>  
     <dependency>  
       <groupId>org.springframework</groupId>  
       <artifactId>spring-aspects</artifactId>  
       <version>${spring.version}</version>  
     </dependency>  
     <dependency>  
       <groupId>joda-time</groupId>  
       <artifactId>joda-time</artifactId>  
       <version>2.0</version>  
     </dependency>  
     <dependency>  
       <groupId>joda-time</groupId>  
       <artifactId>joda-time-hibernate</artifactId>  
       <version>1.3</version>  
     </dependency>  
     <dependency>  
       <groupId>com.google.guava</groupId>  
       <artifactId>guava</artifactId>  
       <version>r05</version>  
     </dependency>  
     <dependency>  
       <groupId>org.hibernate</groupId>  
       <artifactId>hibernate-entitymanager</artifactId>  
       <version>3.6.10.Final</version>  
     </dependency>  
   </dependencies>  


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.





Ya que tenemos todas las dependencias necesarias para poder realizar nuestro proyecto vamos a crear  nuestra base de datos en mysql.


 create database springdata;  
 use springdata;  
 CREATE TABLE Persona(  
      id_persona INTEGER PRIMARY KEY AUTO_INCREMENT,  
      nombre VARCHAR(30) NOT NULL,  
      ap_pat VARCHAR(30),  
      ap_mat VARCHAR(30),  
      edad INTEGER,  
      sexo CHAR(1)  
 );  


Ya creada la base de datos lo que vamos a crear un paquete dentro de "Source Packages" haremos click secundario en dicho paquete y seleccionaremos "New ->Other", en la pantalla que nos aparecerá seleccionaremos "Persistence->Entity Classes from Database" y hacemos click en "Next".



En la opción "Database Connection" seleccionaremos "New Database Connection", en la opción "Driver" vamos a elegir donde dice "MySQL (Connector/J driver) " y hacemos click en "Next".


Colocaremos la información sobre la base de datos a la cual nos vamos a conectar, hacemos click en el botón "Test Connection" y si nos arroja un "Connection Succeeded" hacemos click en "Finish".


Seleccionamos la tabla personas en la lista oprimimos el botón "Add" y hacemos click en siguiente.


Dejamos las opciones por defecto en la siguiente pantalla hacemos click en "Next", en la opción "Collection Type" seleccionaremos "java.util.List" y hacemos click en "Finish".


Como pueden ver se creó una clase Java que representa a la tabla en la base de datos que seleccionamos, es importante mencionar que hasta ahorita no hemos hecho nada de Spring Data, esta es configuración y la creación de una entity de JPA.Ahora borremos las cosas que no vamos a necesitar como las @NamedQueries de tal modo que quede de la siguiente forma:

 package mx.com.geeksjava.ejemplospringdata.model;  
 import java.io.Serializable;  
 import javax.persistence.Basic;  
 import javax.persistence.Column;  
 import javax.persistence.Entity;  
 import javax.persistence.GeneratedValue;  
 import javax.persistence.GenerationType;  
 import javax.persistence.Id;  
 import javax.persistence.Table;  
 import javax.xml.bind.annotation.XmlRootElement;  
 @Entity  
 @Table(name = "persona")  
 @XmlRootElement  
 public class Persona implements Serializable {  
   private static final long serialVersionUID = 1L;  
   @Id  
   @GeneratedValue(strategy = GenerationType.IDENTITY)  
   @Basic(optional = false)  
   @Column(name = "id_persona")  
   private Integer idPersona;  
   @Basic(optional = false)  
   @Column(name = "nombre")  
   private String nombre;  
   @Column(name = "ap_pat")  
   private String apPat;  
   @Column(name = "ap_mat")  
   private String apMat;  
   @Column(name = "edad")  
   private Integer edad;  
   @Column(name = "sexo")  
   private Character sexo;  
   public Persona() {  
   }  
   public Persona(Integer idPersona) {  
     this.idPersona = idPersona;  
   }  
   public Persona(Integer idPersona, String nombre) {  
     this.idPersona = idPersona;  
     this.nombre = nombre;  
   }  
   public Integer getIdPersona() {  
     return idPersona;  
   }  
   public void setIdPersona(Integer idPersona) {  
     this.idPersona = idPersona;  
   }  
   public String getNombre() {  
     return nombre;  
   }  
   public void setNombre(String nombre) {  
     this.nombre = nombre;  
   }  
   public String getApPat() {  
     return apPat;  
   }  
   public void setApPat(String apPat) {  
     this.apPat = apPat;  
   }  
   public String getApMat() {  
     return apMat;  
   }  
   public void setApMat(String apMat) {  
     this.apMat = apMat;  
   }  
   public Integer getEdad() {  
     return edad;  
   }  
   public void setEdad(Integer edad) {  
     this.edad = edad;  
   }  
   public Character getSexo() {  
     return sexo;  
   }  
   public void setSexo(Character sexo) {  
     this.sexo = sexo;  
   }  
   @Override  
   public int hashCode() {  
     int hash = 0;  
     hash += (idPersona != null ? idPersona.hashCode() : 0);  
     return hash;  
   }  
   @Override  
   public boolean equals(Object object) {  
     // TODO: Warning - this method won't work in the case the id fields are not set  
     if (!(object instanceof Persona)) {  
       return false;  
     }  
     Persona other = (Persona) object;  
     if ((this.idPersona == null && other.idPersona != null) || (this.idPersona != null && !this.idPersona.equals(other.idPersona))) {  
       return false;  
     }  
     return true;  
   }  
   @Override  
   public String toString() {  
     return "mx.com.geeksjava.ejemplospringdata.model.Persona[ idPersona=" + idPersona + " ]";  
   }  
 }  




Ahora vamos a crear un archivo properties de donde se cargará la información de la base de datos para esto, nos vamos a la carpeta "Other Sources" hacemos click secundario "New->Properties File", colocamos el nombre "conexion" y hacemos click en "Finish".



conexion.properties

 database.url=jdbc:mysql://localhost:3306/springdata
 database.driver=com.mysql.jdbc.Driver  
 database.username=root  
 database.password=hola123  

Dentro de "Source Packages" vamos a crear un paquete llamado "mx.com.geeksjava.ejemplospringdata.repository" y dentro de la carpeta "Other Sources" vamos a crear un archivo xml al que nombraremos "jpaApplicationContext.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"  
      xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"  
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
           http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.0.xsd  
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">  
      <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">  
           <property name="driverClassName" value="${database.driver}"></property>  
           <property name="url" value="${database.url}"></property>  
           <property name="username" value="${database.username}"></property>  
           <property name="password" value="${database.password}"></property>  
      </bean>  
      <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">  
           <property name="entityManagerFactory" ref="emf"></property>  
      </bean>  
      <context:property-placeholder location="classpath:conexion.properties" />  
      <tx:annotation-driven transaction-manager="transactionManager" />  
      <bean id="emf"  
           class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
           <property name="dataSource" ref="dataSource" />  
           <property name="jpaVendorAdapter">  
                <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />  
           </property>  
           <property name="packagesToScan"  
                value="mx.com.geeksjava.ejemplospringdata.model" />  
           <property name="jpaProperties">  
                <props>  
                     <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
                     <prop key="hibernate.max_fetch_depth">3</prop>  
                     <prop key="hibernate.jdbc.fetch_size">50</prop>  
                     <prop key="hibernate.jdbc.batch_size">10</prop>  
                     <prop key="hibernate.show_sql">true</prop>  
                </props>  
           </property>  
      </bean>  
      <jpa:repositories base-package="mx.com.geeksjava.ejemplospringdata.repository"  
           entity-manager-factory-ref="emf" transaction-manager-ref="transactionManager"></jpa:repositories>  
      <context:annotation-config></context:annotation-config>  
      <context:component-scan base-package="mx.com.geeksjava.ejemplospringdata"></context:component-scan>  
 </beans>  


Con esto vamos a configurar Spring Data, lo que resta ya simplemente es utilizarlo y probar su funcionamiento, para esto vamos a crear una interfaz llamada "PersonaRepository" dentro del paquete "mx.com.geeksjava.ejemplospringdata.repository".


Ahora lo que vamos a modificarla de tal modo que quede de la siguiente forma.

 package mx.com.geeksjava.ejemplospringdata.repository;  
 import mx.com.geeksjava.ejemplospringdata.model.Persona;  
 import org.springframework.data.repository.CrudRepository;  
 import org.springframework.stereotype.Repository;  
 @Repository("personaRepository")  
 public interface PersonaRepository extends CrudRepository<Persona,Integer>{  
   public Persona findByNombre(String nombre);  
 }  


Como se puede ver la interfaz PersonaRepository hereda de CrudRepository y le pasamos 2 genéricos, el primero representa la entidad con la cual se va a trabajar y el segundo el tipo de dato de la llave primaria. Dentro de la interfaz definimos el método "findByNombre(String nombre)" con esto aunque nosotros no lo hagamos Spring Data realizará la implementación para buscar en la base de datos el nombre que le mandemos y nos devolverá un objeto de tipo persona con el resultado.

Para probarlo utilizaremos el Framework JUnit, para esto nos iremos a la carpeta "Test Packages"  y crearemos el paquete "mx.com.geeksjava.ejemplospringdata" dentro de ese paquete hacemos la siguiente clase.




 package mx.com.geeksjava.ejemplospringdata;  
 import mx.com.geeksjava.ejemplospringdata.model.Persona;  
 import mx.com.geeksjava.ejemplospringdata.repository.PersonaRepository;  
 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;  
 import static org.junit.Assert.*;  
 @ContextConfiguration("/jpaApplicationContext.xml")  
 @RunWith(SpringJUnit4ClassRunner.class)  
 public class PersonaRepositoryTest {  
   @Autowired  
   private PersonaRepository personaRepository;  
   @Test  
   public void pruebaBusqueda() {  
     personaRepository.deleteAll();  
     Persona p = new Persona();  
     p.setApMat("Sánchez");  
     p.setApPat("López");  
     p.setNombre("Juan");  
     p.setSexo('m');  
     p.setEdad(12);  
     personaRepository.save(p);      
     Persona q = personaRepository.findByNombre("Juan");  
     assertEquals(p.getNombre(), q.getNombre());  
   }  
   @Test  
   public void pruebaBorrar() {  
     Persona p = new Persona();  
     p.setNombre("Mario Orlando Hardy ");  
     p.setApPat("Hamlet Brenno");  
     p.setApMat("Benedetti Farrugia");  
     p.setSexo('m');  
     p.setEdad(93);  
     Persona q = new Persona();  
     q.setNombre("Jaime");  
     q.setApPat("Sabines");  
     q.setApMat("Gutiérrez");  
     q.setSexo('m');  
     q.setEdad(72);  
     personaRepository.save(p);      
     personaRepository.save(q);  
     personaRepository.deleteAll();  
     Iterable<Persona> personas = personaRepository.findAll();  
     assertEquals(false, personas.iterator().hasNext());  
   }  
 }  


Este es un test de JUnit el cual tiene dos pruebas la primera valida que se guarde un elemento y la soegunda que se borre todo el contenido de la tabla, como se puede ver personaRepository es un objeto de la interfaz que creamos "PersonaRepository" y nosotros nunca implementamos los métodos "save", "deleteAll" ni "findByNombre". La implementación de estos métodos fue hecha por Spring Data.



En este ejemplo solo creamos una tabla con su entidad y con su repository pero en una aplicación normal tendremos muchas tablas con sus entidades y sus repositories, como pueden ver el código que ahorramos fue muchísimo y fue muy limpio ya que no hicimos conexiones a la base de datos, no utilizamos nada de sql o jpql, no realizamos las implementaciones para crear, leer, actualizar ni borrar nada en la base de datos, todo lo hizo Spring Data por nosotros.

Si comparamos el desarrollo de software con el Fútbol esto sería como un "Programa Bonito".


Espero les haya quedado claro la forma en la que podemos utilizar Spring Data y las ventajas que nos da en el desarrollo de software.

El código completo EjemploSpringData.rar.



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

jueves, 18 de julio de 2013

Diseño y desarrollo de un videojuego utilizando Java Swing Api


En este artículo se explicará como desarrollar un videojuego sencillo utilizando el API de Java Swing, este artículo asume que tienes conocimiento básicos de java y conocimientos sobre Programación Orientada a Objetos. Para el desarrollo se utilizará el IDE Netbeans 7.3.




Lo primero que tenemos que hacer es crear un proyecto dentro de nuestro entorno de desarrollo, para eso seleccionamos la opción "New Proyect" de NetBeans como se muestra en la siguiente imagen.


Seleccionaremos la opción "Java --> Java Application" y hacemos click en "Next".


Colocamos el nombre del proyecto y des habilitamos el checkbox  "Create Main Class" y hacemos click en "Finish".


Lo siguiente que haremos será ir a la ruta en la cual se creo el proyecto, esto es en la carpeta  "Documents\NetBeansProjects\GameGeeksJavaMexico" y crearemos una carpeta llamada "images", en esta carpeta colocaremos las imágenes que van a aparecer en nuestro juego, se recomienda que estén en formato ".png", un buen sitio donde pueden encontrar algunas imágenes para hacer su juego es en la página http://www.iconarchive.com/ .


A continuación dentro de NetBeans crearemos 3 paquetes uno llamado modelo, util y vista. Dentro de estos paquetes colocaremos todas las clases que necesitaremos a lo largo del juego.


Dentro del paquete modelo voy a crear una clase abstracta llamada Sprite.

 package modelo;  
 import java.awt.Graphics;  
 public abstract class Sprite {  
   protected int x;  
   protected int y;  
   protected int width;  
   protected int heigth;  
   public Sprite() {  
   }  
   public Sprite(int x, int y, int width, int heigth) {  
     this.x = x;  
     this.y = y;  
     this.width = width;  
     this.heigth = heigth;  
   }  
   public abstract void draw(Graphics g);  
   public int getX() {  
     return x;  
   }  
   public void setX(int x) {  
     this.x = x;  
   }  
   public int getY() {  
     return y;  
   }  
   public void setY(int y) {  
     this.y = y;  
   }  
   public int getWidth() {  
     return width;  
   }  
   public void setWidth(int width) {  
     this.width = width;  
   }  
   public int getHeigth() {  
     return heigth;  
   }  
   public void setHeigth(int heigth) {  
     this.heigth = heigth;  
   }  
   @Override  
   public String toString() {  
     return "Sprite{" + "x=" + x + ", y=" + y + ", width=" + width + ", heigth=" + heigth + '}';  
   }  
 }  

La clase Sprite dentro de nuestra aplicación nos servirá para representar a los objetos "Dibujables" dentro de nuestra aplicación, por este motivo la clase Sprite sabe que se tiene que dibujar pero no sabe como, esto dependerá de que tipo de objeto sea, por esto el método draw es un método abstracto y la clase esta marcada como abstracta.

A continuación crearemos una enumeración dentro del paquete model llamada TipoDeMalo.


 package modelo;  
 public enum TipoDeMalo {  
   PULPO("images/zombie.png", 2), DIABLO("images/zombie2.png", 8), ZOMBIE("images/zombie3.png", 5);  
   private String path;  
   private int velocity;  
   private TipoDeMalo(String path, int velocity) {  
     this.path = path;  
     this.velocity = velocity;  
   }  
   public String getPath() {  
     return path;  
   }  
   public void setPath(String path) {  
     this.path = path;  
   }  
   public int getVelocity() {  
     return velocity;  
   }  
   public void setVelocity(int velocity) {  
     this.velocity = velocity;  
   }  
 }  


Los valores de la enumeración son PULPO,DIABLO y ZOMBIE, por cada uno se tiene su imagen a cargar y un número que representa una velocidad, esto es porque los malos van a ir cayendo a velocidades diferentes dependiendo de que tipo de malo sean. 

De igual modo dentro del paquete modelo crearemos una clase llamada Malo.

 package modelo;  
 import java.awt.Graphics;  
 import java.awt.Image;  
 import javax.swing.ImageIcon;  
 public class Malo extends Sprite {  
   private TipoDeMalo zombieType;  
   private static final TipoDeMalo ZT[]={TipoDeMalo.DIABLO, TipoDeMalo.PULPO, TipoDeMalo.ZOMBIE};  
   public Malo(int x, int y, int width, int heigth) {  
     super(x, y, width, heigth);  
     zombieType=ZT[((int)(Math.random()*3))];  
   }  
   public Malo() {  
   }  
   @Override  
   public void draw(Graphics g) {      
     Image image = new ImageIcon(zombieType.getPath()).getImage();  
     g.drawImage(image, x, y, width,heigth,null);  
     y+=zombieType.getVelocity();  
   }  
   public TipoDeMalo getTipoDeMalo() {  
     return zombieType;  
   }  
   public void setTipoDeMalo(TipoDeMalo zombieType) {  
     this.zombieType = zombieType;  
   }  
 }  

Como se puede observar la clase Malo hereda de la clase Sprite, por tal motivo debe implementar el método draw en el cual se debe implementar lo que queremos que se haga cuando se dibuje, en este caso el comportamiento deseado es que se aumente la posición en "y" dependiendo de la velocidad para así ver como se desplaza hacia abajo el personaje. Otra cosa importante es que se tiene un atributo de tipo TipoDeMalo para así poder asignar de manera aleatoria que tipo de malo queremos que se genere, en este ejemplo pueden ser DIABLO, PULPO o ZOMBIE.

Ahora vamos a crear a un héroe para nuestro juego, para esto crearemos otra clase llamada Heroe dentro del paquete modelo, esta clase también se podrá dibujar en la pantalla, por tal motivo debe heredar de la clase Sprite.

 package modelo;  
 import java.awt.Graphics;  
 import java.awt.Image;  
 import javax.swing.ImageIcon;  
 public class Heroe extends Sprite {  
   public Heroe() {  
   }  
   public Heroe(int x, int y, int width, int heigth) {  
     super(x, y, width, heigth);  
   }  
   @Override  
   public void draw(Graphics g) {  
     Image image = new ImageIcon("images/baby.png").getImage();  
     g.drawImage(image, x, y, width, heigth, null);  
   }  
 }  

Como se puede observar el método dibujar de la clase Heroe solo se encarga de dibujar la imagen del héroe ya que los movimientos de las coordenadas "x" y "y" se realizarán en el momento que se genere un evento, esto se explicará con más detalle más adelante.

Para terminar de hacer nuestras clases de modelo, crearemos una clase llamada Bala.

 package modelo;  
 import java.awt.Graphics;  
 import java.awt.Image;  
 import javax.swing.ImageIcon;  
 public class Bala extends Sprite {  
   public static final int SIZE = 30;  
   public Bala() {  
   }  
   public Bala(int x, int y, int width, int heigth) {  
     super(x, y, width, heigth);  
   }  
   @Override  
   public void draw(Graphics g) {  
     Image image = new ImageIcon("images/bean.png").getImage();  
     g.drawImage(image, x, y, width, heigth, null);  
     y -= 30;  
   }  
 }  

Como las balas también se van a dibujar dentro de nuestro escenario también deben de heredar de nuestra clase Sprite, como se puede observar el método dibujar solo reduce la posición en "y" esto es porque las balas van hacia arriba, "también se pudo crear una enumeración con tipos de balas para dependiendo del tipo dispare más rápido".

Con estas sencillas clases de modelo que creamos ya tenemos un buen avance para nuestro juego, ahora lo que resta es crear un manejador de eventos y una pantalla en la cual se van a dibujar nuestros malos nuestras balas y nuestro héroe. Primero crearemos nuestra clase ManejadorDeEventos en el paquete util.

 package util;  
 import java.awt.event.KeyAdapter;  
 import java.awt.event.KeyEvent;  
 import java.awt.event.KeyListener;  
 import java.util.List;  
 import modelo.Bala;  
 import modelo.Sprite;  
 public class ManejadorDeEventos extends KeyAdapter implements KeyListener {  
   private Sprite hero;  
   private List<Sprite> sprites;  
   public ManejadorDeEventos(Sprite hero, List<Sprite> sprites) {  
     this.hero = hero;  
     this.sprites = sprites;  
   }  
   @Override  
   public void keyPressed(KeyEvent e) {  
     super.keyPressed(e);  
     switch (e.getKeyCode()) {  
       case KeyEvent.VK_LEFT:  
         hero.setX(hero.getX() - 50);  
         break;  
       case KeyEvent.VK_RIGHT:  
         hero.setX(hero.getX() + 50);  
         break;  
       case KeyEvent.VK_UP:  
         hero.setY(hero.getY() - 50);  
         break;  
       case KeyEvent.VK_DOWN:  
         hero.setY(hero.getY() + 50);  
         break;  
       case KeyEvent.VK_SPACE:  
         Sprite s = new Bala(hero.getX(), hero.getY(), Bala.SIZE, Bala.SIZE);  
         sprites.add(s);  
         break;  
     }  
   }  
 }  

Esta clase será la encargada de manejar los eventos en el juego, por esto necesita dos atributos, una referencia hacia el héroe del juego y una lista de objetos dibujables en el juego. Como se puede observar estamos heredando de la clase KeyAdapter e implementando la interfaz KeyListener, esto para manejar eventos que provienen desde el teclado, dentro del método keyPressed que es el que se ejecutará en el momento en el que se oprima una tecla estamos validando qué tecla se oprimió, en caso de que sea la flecha izquierda se le restarán 50 a la posición del héroe en el eje "x", en caso de que sea a la derecha se sumará 50 a su posición en "x",en caso de que se oprima la flecha hacia arriba se restará 50 a la posición en "y", en caso de que se oprima la flecha hacia abajo se sumará 50 en la posición en el eje "y" y por último se valida si se oprimió la tecla de espacio se creará una nueva bala con la posición en "x" y en "y" del  héroe y con el tamaño definido en la constante SIZE de la clase Bala.

Ahora vamos a ver como quedaría la clase Lienzo que es en la cual se dibujarán los objetos, esta debe ir en el paquete vista.

 package vista;  
 import java.awt.Graphics;  
 import java.awt.Image;  
 import java.util.ArrayList;  
 import java.util.List;  
 import javax.swing.ImageIcon;  
 import javax.swing.JPanel;  
 import modelo.Heroe;  
 import modelo.Malo;  
 import modelo.Sprite;  
 import util.ManejadorDeEventos;  
 public class Lienzo extends JPanel {  
   public static final int ANCHO = 370;  
   public static final int ALTO = 700;  
   private List<Sprite> sprites;  
   private Sprite hero;  
   public Lienzo() {  
     init();  
   }  
   private void init() {  
     sprites = new ArrayList<Sprite>();  
     hero = new Heroe(100, 600, 50, 50);  
     sprites.add(hero);  
     ManejadorDeEventos me = new ManejadorDeEventos(hero, sprites);  
     addKeyListener(me);  
     setFocusable(true);  
   }  
   public void agregarMalo() {  
     int arr[] = {0, 100, 200, 300};  
     Sprite s3 = new Malo(arr[((int) (Math.random() * arr.length))], 0, 50, 50);  
     sprites.add(s3);  
   }  
   @Override  
   public void paint(Graphics g) {  
     super.paint(g);  
     Image image = new ImageIcon("images/background-game.jpg").getImage();  
     g.drawImage(image, 0, 0, 410, 700, this);  
     for (Sprite sprite : sprites) {  
       sprite.draw(g);  
     }  
   }  
   public void play() throws Exception {  
     long init = System.currentTimeMillis() + 800;  
     while (true) {  
       Thread.sleep(80);  
       Long time = System.currentTimeMillis();  
       if (time > init) {  
         init = System.currentTimeMillis() + 800;  
         agregarMalo();  
       }  
       repaint();  
     }  
   }  
 }  


La clase Lienzo es de las clases más importantes dentro del juego, ya que este es el lugar en el cual se van a pintar nuestros personajes, como se puede ver esta clase hereda de la clase JPanel. Dentro de esta clase tenemos como atributos una lista de sprites que es la lista de todos los objetos que se redibujarán y un héroe para nuestro juego, estos atributos son inicializados en el método init, a demás el método init se encarga de asignar el manejador de eventos que creamos y decirle cual es la lista y cual es el héroe de nuestro juego.


El juego inicia llamando al método play, dentro de este método tenemos un ciclo infinito y un pequeño retardo, cada cierto tiempo (800 milisegundos) se va a mandar llamar al método agregarMalo() el cual agrega un malo aleatorio en una posición aleatoria del campo y después redibuja el escenario. En el método paint colocamos el fondo de nuestro juego y redibujamos todos los sprites que están involucrados en el juego, el método paint se invocará de forma implícita cada vez que mandemos llamar al métod repaint().

Por último y para probar nuestro juego vamos a crear una clase llamada Juego.

 package vista;  
 import javax.swing.JFrame;  
 public class Juego {  
   public static void main(String[] args) throws Exception {  
     JFrame jf=new JFrame();  
     Lienzo l=new Lienzo();  
     jf.add(l);  
     jf.setSize(Lienzo.ANCHO,Lienzo.ALTO);  
     jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
     jf.setVisible(true);  
     l.play();  
   }  
 }  

Dentro de la clase Juego simplemente crearemos un JFrame y un Lienzo, el lienzo lo agregaremos al frame lo haremos visible y llamaremos al método play, veamos como se ve el juego en ejecución.


Como pueden ver si se siguen conceptos de Programación Orientada a Objetos se puede realizar un juego y cualquier otra aplicación de forma muy sencilla, si tienen alguna duda sobre el código no duden en preguntar en la sección de comentarios y esperen los siguientes post's sobre diversos frameworks y herramientas de java. 


Coloco adjunto el proyecto en el siguiente archivo GameGeeksJavaMexico.rar


Gracias y espero sea de su utilidad.

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