Java EE 8. Componentes de la capa de datos, entitys, dao e interfaces

Crear entitys de las tablas

Primero se debe verificar en la ventana Data Source Explorer que la conexión a las Base de Datos esta activa.

Coneccion activa

Clic derecho sobre el proyecto -> New -> Other… -> JPA -> JPA Entities from Tables.

JPA Entities from Tables

Seleccionar la conexión, el esquema y las tablas. También debemos asegurarnos que la opción List generated classes in persistence.xml este habilitado. En nuestro caso seleccionamos las tablas Logins_users y Users y clic en Next >.

Seleccionar tablas

Muestra la relaciones entre las tablas. Clic en Next.

Relaciones entre las tablas

En el campo Package: de la sección Domain java class elegimos el paquete donde se generaran los entitys. en nuestro caso com.aor.test.entity. Clic en Next >.

Seleccionar paquete

Aquí podemos editar cualquier campo de la tabla de forma individual desplegando la tabla y seleccionando el campo.

editar de forma individual

Lo recomendable es dejar todo como esta y clic en Finish.

Editar de forma individual

Nos vamos al paquete de com.aor.test.entity y podemos ver las clases entity que se generaron.

Entity generados


 

Descripción de entity

Los entity son JavaBean con anotaciones

  1. @Entity. Anotación que indica que es un entity
  2. @Table(name=»Users»). Anotación que indica que hace referencia a la tabla correspondiente.
  3. @NamedQuery(name=»User.findAll», query=»SELECT u FROM User u»). Anotación que muestra los querys que podemos utilizar en la aplicación.
  4. @OneToMany(mappedBy=»user»). Anotación que indica las relaciones con otras tablas.
  5. Cuenta con los métodos get y set como un JavaBean.

entity


 

Crear interfaces

Clic derecho sobre el paquete com.aor.test.entityinterface  -> New -> Interface. Escribir en el campo Name: IDaoLogins_user. Clic en Finish.

Crear interface

Abrimos la interfaz y escribimos todos los métodos que vamos a ocupar sobre la tabla. Los más comunes son: insert, update, delete.  Para el caso de los select es más recomendable poner una descripción más precisa por ejemplo, logins_userFindAll, el cual indica que obtenemos todos los datos de la tabla logins_user. Siempre ponemos primero el nombre de la tabla en minúsculas y posteriormente la acción. Otro ejemplo, logins_userById significa que queremos obtener los registros de la tabla logins_user por el campo id.

Tecleamos los métodos de la interfaz.

public boolean insert(EntityManager em,Logins_user logins_user) throws Exception;
public boolean update(EntityManager em,Logins_user logins_user) throws Exception;
public boolean delete(EntityManager em,Logins_user logins_user) throws Exception;
public List<Logins_user> logins_userFindAll(EntityManager em) throws Exception;
  • EntityManager em, es parte de la API de JPA para gestionar los entitys.
  • Logins_user logins_user, entity correspondiente.
  • logins_userFindAll. Regresa un lista de Logins_user.

El resultado será.

Metodos de la interfaz

Creamos la interfaz para users.

  • Nombre de la interfaz: IDaoUser
  • Métodos:
    public boolean insert(EntityManager em,User user) throws Exception;
    public boolean update(EntityManager em,User user) throws Exception;
    public boolean delete(EntityManager em,User user) throws Exception;
    public List<User> userfindAll(EntityManager em) throws Exception;
    

El resultado será:

metodo de la interfaz de user


 

Crear DAO

Son la implementación de la interfaz.

Clic derecho sobre el paquete com.aor.test.dao -> New -> Class. Escribir en el campo Name: DaoLogins_user. Clic en Add…, seleccionar la interfaz IDaoLogins_user y Clic en Finish.

implementar interfaz Logins_user

Tecleamos los métodos de la clase.

        @Override
	public boolean insert(EntityManager em, Logins_user logins_user) throws Exception {
		em.persist(logins_user);
		return true;
	}

	@Override
	public boolean update(EntityManager em, Logins_user logins_user) throws Exception {
		em.merge(logins_user);
		return true;
	}

	@Override
	public boolean delete(EntityManager em, Logins_user logins_user) throws Exception {
		em.remove(logins_user);
		return true;
	}

	@Override
	public List<Logins_user> logins_userFindAll(EntityManager em) throws Exception {
		TypedQuery<Logins_user> query = em.createNamedQuery("Logins_user.findAll", Logins_user.class);
		List<Logins_user> logins_user = query.getResultList();
		return logins_user;
	}
  • persist, merge, remove y createNamedQuery son métodos que proporciona la API de JPA.
  • El método createNamedQuery toma como parámetro el nombre de la anotación @NamedQuery del entity User.

El resultado será.

metodo de la clase

Creamos la clase para users.

  • Nombre de la clase: DaoUser
  • Métodos:
    	@Override
    	public boolean insert(EntityManager em, User user) throws Exception {
    		em.persist(user);
    		return true;
    	}
    	@Override
    	public boolean update(EntityManager em, User user) throws Exception {
    		em.merge(user);
    		return true;
    	}
    	@Override
    	public boolean delete(EntityManager em, User user) throws Exception {
    		em.remove(user);
    		return true;
    	}
    	@Override
    	public List<User> userfindAll(EntityManager em) throws Exception {
    		TypedQuery<User> query = em.createNamedQuery("User.findAll", User.class);
    		List<User> user = query.getResultList();
    		return user;
    	}
    

El resultado será:

Metodos de la clase

 


Resultado final

Finalmente tenemos para user y logins_user los entity, interfaz de entity, dao e interfaz de dao.

finalmente

 

Java EE 7. Crear estructura del proyecto

Vamos a crear la estructura del proyecto en Eclipse para que cumpla con las capas que propone la arquitectura JEE de java.

Crear paquetes

Para crear los paquetes en el proyecto, nos posicionamos en appWeb -> Java Resources -> src/main/java, clic con el botón derecho del mouse ->New -> Package. Escribir Name: y clic en Finish.

new package

Los nombres de los paquetes deben estar en minúsculas.

Crear carpetas

Para crear las carpetas en el proyecto, nos posicionamos en appWeb -> src -> main -> webapp. clic con el botón derecho del mouse ->New -> Folder. Escribir Folder name: y clic en Finish.

Crear Folder


Capa de datos

Parte del back-end

Paquete com.aor.test.entity

  1. Modela las tablas de la Base de Datos en objetos Java.
  2. Contiene todos los entity de las tablas.
  3. Apoyo para el API jpa.

Paquete com.aor.test.entityinterface

  1. Expone los métodos para la comunicación con otras capas.
  2. Cada una de las capas solo se debe de comunicar por interfaces.

Paquete com.aor.test.dao

  1. Todos los métodos para persistir la información.
  2. Toda interacción con la Base de Datos.
  3. Interactúan directamente con los entitys..

Paquete com.aor.test.daointerface

  1. Expone los métodos para la comunicación con otras capas.
  2. Cada una de las capas solo se debe de comunicar por interfaces.

Capa de negocio

Parte del back-end

Paquete com.aor.test.ejb

  1. Se agrega toda la lógica de negocio.
  2. Todos los métodos transaccionales.

Paquete com.aor.test.ejbinterface

  1. Expone los métodos para la comunicación con otras capas.
  2. Cada una de las capas solo se debe de comunicar por interfaces.

Capa de dominio

Parte del back-end

Paquete com.aor.test.jb

  1. JavaBean
  2. Se ocupa para enviar objetos hacia las vistas
  3. Modela una tabla para enviarla a la capa de presentación, por que los entitys son exclusivos para la capa de datos. Esto para evitar problemas de seguridad.

Capa de otros

Parte del back-end

Paquete com.aor.test.appWeb

  1. Tiene el nombre de la aplicación.
  2. Se ocupa para métodos auxiliares o genéricos que se ocuparan en toda la aplicación.
  3. Por ejemplo la encriptación de la contraseña de los usuarios.

Capa de presentación

A excepción del paquete de servlet que es parte del back-end, las carpetas son parte del front-end.

Paquete com.aor.test.servlet

  1. Es el controller
  2. Solo envían y reciben información.
  3. No debe haber ninguna lógica de negocio.

Carpeta por cada tabla de la Base de Datos

  1. El nombre de la carpeta es igual al nombre de la tabla en minúsculas.
  2. Por cada tabla crear una carpeta
  3. En nuestro caso crearíamos las carpetas users y logins_users.
  4. En estas agregaremos todas las acciones, por ejemplo insert, update, delete y select.

Carpeta js/controllers

  1. Para cumplir con el MVC.
  2. Acciones sobre el formulario.
  3. Todos los eventos relacionados con el formulario.

Carpeta js/models

  1. Para cumplir con el MVC.
  2. Modelan un formulario.
  3. Es una analogía de un JavaBean.

Carpeta css

  1. Hojas de estilos particulares.

Carpeta img

  1. Cualquier imagen que se utilice en la aplicación.

Carpeta library

  1. Plug-ins, librerías externas o framework para la vista. Por ejemplo bootstrap.

Resultado

El resultado final es.

Para los paquetes:

Paquetes

Para las carpetas:

Carpetas


NOTAS

  1. La capa de presentación es el conjunto de Servlet’s y JSP’s.
  2. La arquitectura de JEE propone JavaServer Faces, pero tiene los siguiente inconvenientes:
    1. Se pierden las ventajas del HTML5.
    2. El diseñador no puede trabajar de forma paralela, ya que es código del lado del servidor.
    3. No es posible enfocarse cada quien en una capa.
    4. Por esta razón se propone trabajar con Servlet’s y JSP’s.
  3. En el caso de que se necesitara agregar servicios para ser consumidos por otros sistemas, se puede agregar una nueva capa de servicios por encima de la capa EJB. La capa de servicios interactuara con la capa de EJB. Este caso se vera posteriormente.

 

Java EE 6. Conectar Eclipse con MySQL

Configurar JPA

Clic con el botón derecho sobre el proyecto y seleccionar Propiedades. Clic en Project Facets. Asegurarse que este habilitado JPA y tiene seleccionado la versión 2.1.

Selección_154

Conectar con MySQL

En la misma ventana de propiedades, seleccionar JPA y en la sección de Connection clic en Add connection..
Selección_153
Seleccionar MySQL, elegir un nombre para la conección y clic en Next >.

Selección_155
Clic en el icono New Driver Definition.

Selección_156Elegir el driver 5.1.

Selección_157

Pasarse a la pestaña JAR List, seleccionar el driver mysql-connector-java-5.1.0-bin.jar y clic en Remove JAR/Zip para eliminarlo.

Selección_158
Clic en Add JAR/Zip... Ir a la ruta …/developer/db y seleccionar el archivo mysql-connector-java-5.1.38.jar (Se descargo el jar en el articulo http://arieloliva.com/configurar_proyecto/ en la sección «Dependencia para MySQL»). Clic en OK.

Selección_159
Escribir los datos de la Base de Datos MySQL.

Database mydb
URL jdbc:mysql://localhost:3306/mydb
User name root
Password El seleccionado en la instalación

Selección_160

Clic en Test Connection para validar que la conección es correcta.

Selección_161
Clic en Next > y  en Finish.

Validar la conección a MySQL

Sobre Eclipse en la pestaña Data Source Explorer se muestra la conección recién creada. Clic con el botón derecho y Connect.

Selección_163

Introducir la contraseña y OK.

Selección_164
Podemos ver las tablas de la Base de Datos de MySQL.

Selección_165

Java EE 5. Crear Base de Datos MySQL

Vamos a crear una Base de Datos muy sencilla para continuar con el desarrollo JEE.

Crear modelo en MySQL Workbench

Abrimos MySQL Workbench y seleccionamos la instancia local.

Selección_153

Pedirá la contraseña que seleccionamos en la instalación pasada.

Selección_154

En la pantalla principal ir a File -> New Model.

Selección_155

Doble Clic en Add Diagram.

Selección_156

Crear las tablas y sus relaciones

Aquí ya podemos agregar las tablas de la Base de Datos. Damos clic en Place a New Table. y con otro clic sobre el espacio de trabajo se creara la tabla.

Selección_175

Doble clic en la tabla y se mostraran su propiedades en la parte inferior. Seleccionamos el nombre Usuarios.

Selección_159

Y en la pestaña Columns agregamos los campos id, user y password.

Nombre Tipo de dato Clave primaria No acepta null
id INT Si Si
user VARCHAR(10) No No
password VARCHAR(10) No No

Selección_164

Ahora creamos la tabla Logins_users.

Nombre Tipo de dato Clave primaria No acepta null
id INT Si Si
date DATETIME No No
status VARCHAR(5) No No

Selección_166

Relacionamos la tablas de 1 a muchos. Damos clic en Place a New 1:n Non-Identifying.

Selección_167

Clic en la tabla Logins_users y finalmente clic en la tabla Users.

Selección_168

Generar Base de Datos

Ya tenemos nuestro modelo ahora vamos a crear la Base de Datos; Database -> Forward Engineer… Seleccionamos la instancia Local y la contraseña. Clic en Next.

Selección_169

Todo predeterminado y clic en Next.

Selección_170

Debe estar habilitado Export MySQL Table Object. Clic en Next.

Selección_171

Se muestra el script de creación. Clic en Next.

Selección_172

Clic en Close.

Selección_173

Desde la pestaña de la instancia seleccionamos el esquema mydb  y ejecutamos los querys:

select * from Users;
select * from Logins_users;

En la parte inferior se debe mostrar que las consultas fueron exitosas, indicando que las tablas ya existen.

Selección_174

 

Java EE 2. Configurar Eclipse

Introducción

En Java existe una cantidad enorme de librerías que podemos reutilizar para nuestros proyectos, Maven nos proporciona la facilidad de gestionar estas librerías para manejar versiones y dependencias, así como empaquetar y distribuir el proyecto. Para mas detalles: http://www.genbetadev.com/java-j2ee/que-es-maven.

Eclipse ya integra Maven y su uso lo hace muy sencillo. El proyecto Java EE que crearemos será un proyecto Maven

Configurar Eclipse

1. Seleccionar workspace

Al abrir Eclipse por primera vez debemos seleccionar la ruta ../developer/ide/workspace

workspace

2. Crear Archetypes de Maven

Dentro de Eclipse ir a:

Windows -> Preferences -> Maven -> Archetypes

archetype

Clic en el botón Add Remote Catalog.. En el campo Catalog File:  copiamos la ruta: http://repo.maven.apache.org/maven2/archetype-catalog.xml y clic en el botón OK.

archetype2

Se muestra la nueva ruta de Archetypes agregada.

archetype2_1

NOTA: Esta ruta se puede obtener de la pagina oficial de Maven https://maven.apache.org/https://maven.apache.org/archetype/archetype-models/archetype-catalog/archetype-catalog.html

archetype3

3. Configurar el servidor de aplicaciones en Eclipse

Instalar las herramientas de Glassfish.

Dentro de Eclipse ir a:

Help -> Eclipse Marketplace… -> Search

Escribimos glassfish y presionamos el botón Go. Cuando nos muestre  GlassFish Tools damos clic en Install.

glassfishTools

Habilitamos todo y clic en Confirm.

glassfishTools2

Aceptamos la licencia y clic en Finish.

glassfishTools3

Cuando termine  de instalar nos pedirá reiniciar Eclipse. Clic en Yes.

glassfishTools4

NOTA: Si  se muestra un error al instalar el plug-in se puede intentar lo siguiente. http://arieloliva.com/error_glassfish_tools_eclipse/

Configurar GlassFish.

Después de reiniciar Eclipse, seleccionamos la pestaña Servers y clic en No servers are available. Click this link to create a new server…

server

Seleccionamos GlassFish 4 y el nombre del servidor. Presionamos Next.

server2

Seleccionamos la ruta ../developer/server/glassfish4/glassfish donde previamente se descomprimimos el servidor de aplicaciones GlassFish. Clic en Next.

server3

Dejamos el password en blanco y clic en Finish.

server4

Se muestra el servidor. Clic derecho y seleccionamos Start. El servidor debe levantarse.

server6

 

4. Crear proyecto Maven

Dentro de Eclipse ir a:

File -> New -> Other -> Maven -> Maven Project  Next

maven

 Default workspace y clic en Next.

maven2

Escribimos en Filter: J2EE, esperamos a que muestre los Archetype y seleccionamoa webapp-j2ee14 versión 1.3. Clic en Next.

maven3

Escribimos,
 Group Id: paquete inicial del proyecto
 Artifact Id: Nombre del proyecto
Versión: Versión del sistema a desarrollar (1.0.0). Clic en Finish.

maven4

 Clic derecho sobre el proyecto Run As -> 1. Run On Server

maven5

Seleccionamos GlassFish. Clic en Next.

maven6

Pasamos el proyecto a la ventana de Configured y clic en Finish.

maven7

Se muestra la ventana de «hola mundo». Lo cual indica que el proyecto se ejecuto correctamente

maven8

Java EE 1

Antecedentes

Después de programar por muchos años en java, llegue a pensar que dominaba todo el lenguaje, pero me sorprende ver que sólo lo he tocado superficialmente; que sólo utilizo una mínima parte y no he explotado el potencial que tiene. Por esta razón hoy tomo la decisión de profundizar más, específicamente en Java EE (Java Platform, Enterprise Edition). Para los cual iniciare una serie de artículos para implementar esta arquitectura en un proyecto, desde su instalación hasta la construcción de un sistema.

Generar ambiente

Se puede trabajar sobre Linux, Windows o Mac en lo personal me gusta mas Linux (Ubuntu), pero hay que considerar las versiones de las herramientas, así como los detalles específicos; manejo de rutas, tipos de ejecutables  .sh para Linux, .exe para Windows, etc.

Para generar el ambiente de trabajo requerimos lo siguiente.

1. Estructura de carpetas

Lo más conveniente es generar una estructura de trabajo como la siguiente:

Nivel 1 Nivel 2 Nivel 3 Descripción
developer Carpeta raíz
db Base de Datos y los drivers de conexión.
ide
eclipse Instalación de Eclipse
workspace Espacio de trabajo de Eclipse
server Servidor de aplicaciones

Por ejemplo:

estructuraCarpetas

Esta nos permite tener completamente organizado todo el ambiente de trabajo y ubicar perfectamente donde esta cada componente. Por ejemplo si quisiéramos pasarlo a otra maquina bastaría con copiar toda la estructura de carpetas.

2. Descargar las siguientes herramientas

  1. Eclipse.
  2. Glassfish.
  3. JDK 8 de Java.
  4. MySQL Community Server.
    • Link. http://dev.mysql.com/downloads/mysql/
    • Versión. Dependiendo de su Sistema Operativo.
    • Instalación. Descargar el archivo y ejecutarlo. Solo solicita la contraseña del usuario root.
  5. MySQL Workbench.