miércoles, 10 de junio de 2020

JSF con Eclipse

Se requiere tener instalados o configurados los siguientes componentes:


Al final tendremos un proyecto Maven de JSF 2.3 con JPA 2.2, Servlets versión 4, JDK 1.8 y Java EE 8

Primer paso: crear un proyecto web dinámico Maven

Crear un nuevo proyecto como se muestra


Seleccionar la opción Maven y luego Maven Project como se muestra


Configurar el proyecto con las siguientes especificaciones


Elegir el Group Id y Artifact Id de su preferencia. Seleccionar la opción war para indicar que se trata de un proyecto Web


Finalmente se obtendrá un proyecto con la siguiente estructura:



Segundo paso: Modificar el archivo pom.xml

El archivo pom.xml se debe modificar de la siguiente manera para indicar la versión 4 de los Servlets, el JDK 1.8 y la versión 8 de Java EE:

<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>com.jsf</groupId>
   <artifactId>proyectoJSF</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>war</packaging>
   <properties>
      <project.build.sourceEncoding>
         UTF-8
      </project.build.sourceEncoding>
      <project.reporting.outputEncoding>
         UTF-8
      </project.reporting.outputEncoding>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
      <failOnMissingWebXml>false</failOnMissingWebXml>
   </properties>
   <dependencies>
      <dependency>
         <groupId>javax</groupId>
         <artifactId>javaee-api</artifactId>
         <version>8.0</version>
         <scope>provided</scope>
      </dependency>
   </dependencies>
</project>

El proyecto se actualizará.


Tercer paso: Configurar el proyecto

Vamos a la opción propiedades haciendo clic derecho sobre el nombre del proyecto y buscamos la opción Project Facets y modificamos los checkbox dela siguiente manera:



Las versiones de JSF y JPA se modificarán manualmente, pero debemos hacer clic en "Further configuration required..." para realizar los siguientes cambios:



Esto provocará que se genere un archivo XML llamado "persistence.xml", pero usualmente en un lugar incorrecto y debemos modificar su ubicación de "src/main/java" a "src/main/resources". Además, de agregar y/o modificar tres archivos XML más llamados "beans.xml", "web.xml" y "faces-config.xml" dentro de la carpeta WEB-INF


El archivo web.xml se debe modificar de la siguiente manera:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee"
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
 http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
 version="4.0">
 <display-name>proyectoJSF</display-name>
 <servlet>
  <servlet-name>facesServlet</servlet-name>
  <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>facesServlet</servlet-name>
  <url-pattern>*.xhtml</url-pattern>
 </servlet-mapping>
</web-app>


El archivo faces-config.xml se debe modificar de la siguiente manera:

<?xml version="1.0" encoding="UTF-8"?>
<faces-config xmlns="http://xmlns.jcp.org/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
 http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_3.xsd"
 version="2.3">
</faces-config>


El archivo persistence.xml se debe modificar de la siguiente manera para indicar la versión 2.2 de JPA:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
 http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd"
 version="2.2">
 <persistence-unit name="proyectoJSF">
 </persistence-unit>
</persistence>


El archivo beans.xml se debe modificar de la siguiente manera:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
 http://xmlns.jcp.org/xml/ns/javaee/beans_2_0.xsd"
 version="2.0" bean-discovery-mode="annotated">
</beans>


Opcionalmente podemos desactivar la validación del JPA para que no se muestre un error en "persistence.xml". Para ello, vamos a las propiedades, luego a "Validation" y realizamos las siguientes modificaciones.


Cuarto paso: crear un Bean y un XHTML

Se ha creado un proyecto que sigue el patrón de diseño MVC donde el controlador es el archivo "web.xml", para tener la vista enlazada a un Bean, crearemos un nuevo paquete llamado: "proyectoJSF/view" y dentro crearemos un nuevo Bean con la herramienta CDI instalada previamente.



Modificamos el código del Bean creado por:

package proyectoJSF.view;

import javax.enterprise.context.RequestScoped;
import javax.inject.Named;

@Named
@RequestScoped
public class SaludoView {

 private String input;
 private String output;

 public void submit() {
  output = "Hola estimado " + input;
 }

 public String getInput() {
  return input;
 }

 public void setInput(String input) {
  this.input = input;
 }

 public String getOutput() {
  return output;
 }

}


En la carpeta webapp crearemos dos archivos: "index.html" y "prueba1.xhtml" con los siguientes códigos:
  • index.html
<!DOCTYPE html>
<html>
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Proyecto Demo de JSF</title>
 </head>
 <body>
   <h1>Probando JSF</h1>
   <hr />
   <a href="prueba1.xhtml">Prueba #1</a>
 </body>
</html>

  • prueba1.xhtml
<!DOCTYPE html>
<html lang="en" xmlns="http://www.w3.org/1999/xhtml"
   xmlns:f="http://xmlns.jcp.org/jsf/core"
   xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
   <title>Prueba 01</title>
</h:head>
<h:body>
   <h1>Saludando</h1>
   <h:form>
      <h:outputLabel for="input" value="Input" />
      <h:inputText id="input" value="#{saludoView.input}" />
      <h:commandButton value="Submit" action="#{saludoView.submit}">
         <f:ajax execute="@form" render=":output" />
      </h:commandButton>
   </h:form>
   <h:outputText id="output" value="#{saludoView.output}" />
</h:body>
</html>


Tendremos la siguiente estructura en el proyecto:


Quinto paso: Iniciar el proyecto

Debemos agregar el proyecto al servidor una vez que se encuentre activo como se indica:


Luego debe quedar así


Una vez ejecutado el proyecto debemos ir al enlace de prueba #1 e introducir un nombre para ver la respuesta de la página



martes, 2 de junio de 2020

Bootstrap con JSP

La implementación del framework de Front-end Bootstrap en los JSP es idéntica que en los archivos .html. para ver esta hacer clic aquí


Incluir Bootstrap en un JSP

Consideremos la estructura básica de un JSP:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <!--Cuerpo de la página-->
    </body>
</html>


Modificamos la sección "head" para añadir el marco de trabajo:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0, shrink-to-fit=no">
        <!-- Latest compiled and minified CSS -->
        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.5.0/css/bootstrap.min.css">
        <!-- jQuery library -->
        <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
        <!-- Popper JS -->
        <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.16.0/umd/popper.min.js"></script>
        <!-- Latest compiled JavaScript -->
        <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js"></script> 
    </head>
    <body>
        <div class="container-fluid">
            <h1>La clase columna</h1>
            <p>Nota: Se autodimensionan automáticamente en una fila de manera que tienen el mismo tamaño</p>
            <div class="row">
                <div class="col" style="background-color:lavender;">.col</div>
                <div class="col" style="background-color:orange;">.col</div>
                <div class="col" style="background-color:lavender;">.col</div>
                <div class="col" style="background-color:orange;">.col</div>
                <div class="col" style="background-color:lavender;">.col</div>
                <div class="col" style="background-color:orange;">.col</div>
            </div>
        </div>
        <div class="container-fluid">
            <h2>Hoverable Dark Table</h2>
            <div class="table-responsive">
                <table class="table table-dark table-hover">
                    <thead>
                        <tr>
                            <th>Columna 1</th>
                            <th>Columna 2</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>Dato 1.1</td>
                            <td>Dato 2.1</td>
                        </tr>
                        <tr>
                            <td>Dato 1.2</td>
                            <td>Dato 2.2</td>
                        </tr>
                    </tbody>
                </table>
            </div> 
        </div>
    </body>
</html>

Java Collection Framework - JCF

La plataforma Java incluye un framework de colecciones. Este es una arquitectura unificada para representar y manipular colecciones, que permite que las colecciones se manipulen independientemente de los detalles de implementación.


Colecciones

Una colección es un objeto que representa un grupo de objetos (como la clásica clase "Vector").

Ventajas de su aplicación

  • Reduce el esfuerzo de programación al proporcionar estructuras de datos y algoritmos..
  • Aumenta el rendimiento al proporcionar implementaciones de alto rendimiento de estructuras de datos y algoritmos. Esto es debido a que las diversas implementaciones de cada interfaz son intercambiables asegurando que los programas se pueden ajustar cambiando las implementaciones.
  • Proporciona interoperabilidad entre API no relacionadas al establecer un lenguaje común para pasar colecciones de un lado a otro.
  • Reduce el esfuerzo requerido para aprender API al requerir que aprenda múltiples API de colección ad hoc.
  • Reduce el esfuerzo requerido para diseñar e implementar API al no requerir que produzca API de colecciones ad hoc.
  • Fomenta la reutilización del software al proporcionar una interfaz estándar para colecciones y algoritmos con los que manipularlos.


Organización

JCF se divide en dos grandes grupos de interfaces con sus respectivas interfaces que heredan de ellas:
  • java.util.Collection
    • java.util.Set
    • java.util.SortedSet
    • java.util.NavigableSet
    • java.util.Queue
    • java.util.concurrent.BlockingQueue
    • java.util.concurrent.TransferQueue
    • java.util.Deque
    • java.util.concurrent.BlockingDeque
  • java.util.Map
    • java.util.SortedMap
    • java.util.NavigableMap
    • java.util.concurrent.ConcurrentMap
    • java.util.concurrent.ConcurrentNavigableMap
Adicional a ello, tendremos múltiples clases que las implementarán como ArrayList, HashMap, LinkedList, HashSet, entre otros.

java.util.Map
Un mapa es un conjunto de objetos clave y una asignación de cada miembro de ese conjunto a un objeto de valor. La interfaz Map define una API para definir y consultar asignaciones. Map es parte del Java Collections Framework.


java.util.Collection
La agrupación dentro de una Colección puede o no permitir elementos duplicados y puede o no imponer un orden en los elementos.


Las interfaces Queue y BlockingQueue

Una cola (queue) es una colección ordenada de elementos con métodos para extraer elementos, en orden, del encabezado de la cola. Las implementaciones de colas se basan comúnmente en el orden de inserción como en las colas "primero en entrar, primero en salir" (FIFO) o en las colas de "último en entrar, primero en salir" (LIFO).





Fuentes:



viernes, 22 de mayo de 2020

Interfaces

Es un tipo de referencia que está estrechamente relacionado con una clase al tener múltiples similitudes con estas.

Definir una interfaz es muy parecido a definir una clase abstracta:

 
/* se usa la palabra reservada "interface" */
public interface InterfazDeJava{

}


Cuando define una interfaz se crea una referencia similar a una clase con la principal diferencia en que no define ninguna implementación de sus métodos. Además, presenta las siguientes características o restricciones.

  • Una interfaz no puede ser instanciada, por lo que no se define un constructor.
  • Los únicos campos permitidos en una definición de interfaz son constantes que se declaran tanto estáticas como finales.
  • Una interfaz define una API pública. Todos los métodos de una interfaz son implícitamente públicos, incluso si se omite el modificador público. Es un error definir un método protegido o privado en una interfaz.
  • Una interfaz no contiene implementación alguna. Todos los métodos de una interfaz son implícitamente abstractos, incluso si se omite el modificador abstracto.
  • Las interfaces pueden heredar de otras interfaces y pueden soportar herencia múltiple.
  • Son las clases que al implementar una interfaz mediante la palabra reservada "implements" implementan el código de los métodos declarados en una interfaz.
  • Una interfaz puede ser implementada en múltiples clases y una clase puede implementar múltiples interfaces.

Ejemplo de interfaz y su implementación en código

Código de la interfaz:

 public interface Calculadora {

 Float sumar(Float a, Float b);

 Float restar(Float a, Float b);

 Float multiplicar(Float a, Float b);

 Float dividir(Float a, Float b);

 String getMensaje();
}



Código de la clase:

 public class CalculadoraDecimal implements Calculadora {

 private String mensaje;

 public CalculadoraDecimal() {
 }

 @Override
 public Float sumar(Float a, Float b) {
  mensaje = null;
  return a + b;
 }

 @Override
 public Float restar(Float a, Float b) {
  mensaje = null;
  return a + b;
 }

 @Override
 public Float multiplicar(Float a, Float b) {
  mensaje = null;
  return a + b;
 }

 @Override
 public Float dividir(Float a, Float b) {
  if (b == 0) {
   mensaje = "No se puede dividir entre cero";
   return null;
  } else {
   mensaje = null;
   return a / b;
  }
 }

 @Override
 public String getMensaje() {
  return mensaje;
 }

}

Herencia en interfaces

Como se ha mencionado, las interfaces pueden heredar de otras interfaces sus métodos y constantes. Aquí las superinterfaces (similar a las superclases) deben colocarse luego de la palabra reservada "extends"

Herencia simple:


 
/* se usa la palabra reservada "extends " */
public interface InterfazHija extends InterfazPadre{

}

Herencia múltiple:


 
/* se usa la palabra reservada "extends " */
public interface InterfazHija extends InterfazPadre1, InterfazPadre2{

}


Fuentes:

  • Flanagan, D. (2002). JAVA IN A NUTSHELL Desktop Quick Reference (4a ed.). England: Pearson Education.


jueves, 21 de mayo de 2020

Patrón de diseño Facade

Este es un patrón de diseño orientado a la simplificación de los entornos de programación mediante la división del programa en módulo, reduciendo la dependencia que tienen entre ellos al crear un módulo especial llamado Facade (fachada) con el cual interactúa el cliente.

Su aplicación se puede realizar en los siguientes casos

  • Tener una interfaz simple para un subsistema complejo
  • Estructurar varios subsistemas en capas, ya que las fachadas serían el punto de entrada a cada nivel.
  • Desacoplar un sistema de sus clientes y de otros subsistemas, reduciendo dependencias entre los subsistemas y los clientes.


Fachada (Facade): utiliza a los módulos para llevar a cabo las diversas operaciones que el cliente solicita, de manera que el cliente desconoce la complejidad de todo el programa y solo se centra en este.

Subclases (Los módulos): son los que implementan las diferentes funcionalidades del programa. La fachada es quién los invoca. Lo más importante es que no dependen de la fachada, la creación o desaparición de esta no debe afectarlos en absoluto.



Ejemplo con Java

Supongamos que creamos un programa que permite registrar y mostrar licencias de conducir pidiendo el DNI, tipo y categoría. Además, la mayor cantidad de registros son de licencias A1. Entonces podemos emplear el patrón Facade de la siguiente forma


Tenemos una clase llamada "Licencias" que almacena los valores mencionados y un método para visualizar el registro.
package entidades;

public class Licencias {
 private String dni; 
 private String categoria;
 private String tipo;
 
 public Licencias() {
 }

 public String getDni() {
  return dni;
 }

 public void setDni(String dni) {
  this.dni = dni;
 }

 public String getCategoria() {
  return categoria;
 }

 public void setCategoria(String categoria) {
  this.categoria = categoria;
 }

 public String getTipo() {
  return tipo;
 }

 public void setTipo(String tipo) {
  this.tipo = tipo;
 }
 
 public String verDetalle() {
  return String.format("DNI: %s\nLicencia: %s%s", 
    dni,categoria,tipo);
 }
 
}


Creamos la fachada para el caso más usual que serían las licencias A1
package facade;

import entidades.Licencias;

public class CatA1Facade {

 private Licencias licenciaA1;
 
 public CatA1Facade(String dni) {
  licenciaA1 = new Licencias();
  licenciaA1.setDni(dni);
  licenciaA1.setCategoria("A");
  licenciaA1.setTipo("I");
 }
 
 public String verDetalle() {
  return licenciaA1.verDetalle();
 }
}


Creamos la un registro A1 sin aplicar Facade y luego uno aplicándolo.
package test;

import entidades.Licencias;
import facade.CatA1Facade;

public class Ejecutor {

 public static void main(String[] args) {

  // Sin Facade
  Licencias licenciaA1 = new Licencias();
  licenciaA1.setDni("70686223");
  licenciaA1.setCategoria("A");
  licenciaA1.setTipo("I");
  System.out.println(licenciaA1.verDetalle());
  
  // Con Facade
  CatA1Facade a1Facade = new CatA1Facade("78465521");
  System.out.println(a1Facade.verDetalle());  
 }
}

Estructura del proyecto:

Se puede apreciar que existe una simplicidad en la generación de estos al evitar repetir código.

sábado, 16 de mayo de 2020

Java Standard Tag Library

JSTL es la biblioteca de etiquetas estándar de Java, que darán soporte a los JSP y es uno de los componentes de JAVA EE.

Su utilizad radica en que permite la creación de páginas web dinámicas de forma más eficiente que si no se les usara. Además,  aprovecha el "request", donde almacena variables, datos, etc. para dar soporte a la página JSP desde un servlet.

Cuenta con 6 bibliotecas que la componen:
  • core, iteraciones, condicionales, manipulación de URL y otras funciones generales.
  • biblioteca de funciones
  • xml, para la manipulación de XML y para XML-Transformation.
  • sql, para gestionar conexiones a bases de datos.
  • TLV
  • fmt, para la internacionalización y formateo de las cadenas de caracteres como cifras.

Para agregar esta biblioteca a un proyecto web en Netbeans se sigue los siguientes pasos:

Primero se debe agregar una nueva biblioteca:

Luego seleccionar JSTL y agregar

Dentro de los archivos JSP podemos emplear la paleta que provee Netbeans. Para ello, se hace los siguiente

Aparecerá una barra lateral donde se debe ubicar los siguiente


JSTL CORE


<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSTL - JavaJhon</title>        
    </head>
    <body>
        <strong>Usando JSTL IF</strong>
        <!--Suponemos que hemos capturado o recibido un valor 
        numérico y lo almacenamos en una variable "nota", luego 
        realizamos una comparación con otro valor.-->
        <% Double nota = 20d;%>
        <c:if test="<%= nota>11.5d %>">
            <p>Felicidades ustes ha aprobado con nota: <%= nota%></p>
        </c:if>
        <hr/>
        <br/>        
        <strong>Usando JSTL CHOOSE</strong>
        <!--Suponemos que hemos capturado o recibido un valor 
        numérico y lo almacenamos en una variable "dia", luego 
        realizamos una comparación con otros valores.-->
        <% Integer dia = 6;%>
        <c:choose>
            <c:when test="<%= dia== 1%>">
                <p>Es lunes</p>
            </c:when>
            <c:when test="<%= dia== 2%>">
                <p>Es martes</p>
            </c:when>
            <c:when test="<%= dia== 3%>">
                <p>Es miércoles</p>
            </c:when>
            <c:when test="<%= dia== 4%>">
                <p>Es jueves</p>
            </c:when>
            <c:when test="<%= dia== 5%>">
                <p>Es viernes</p>
            </c:when>
            <c:when test="<%= dia== 6%>">
                <p>Es sábado</p>
            </c:when>
            <c:when test="<%= dia== 7%>">
                <p>Es domingo</p>
            </c:when>
            <c:otherwise>
                <p>Valor erróneo</p>
            </c:otherwise>
        </c:choose>        
        <hr/>
        <br/>
        <strong>Usando JSTL FOR</strong><br/>
        <!--Suponemos que hemos capturado o recibido un valor 
        numérico y lo almacenamos en una variable "n", luego 
        creamos una lista desplegable con valores del 1 a "n"-->
        <% Integer n = 12;%>
        <select>
            <c:forEach var="i" begin="1" end="<%= n %>">
                    <option value="${i}">Item ${i}</option>
            </c:forEach>   
        </select>     
        <hr/>
        <br/>
    </body>
</html>

Obtendremos el siguiente resultado:


Usando JSTL IF
Felicidades ustes ha aprobado con nota: 20.0


Usando JSTL CHOOSE
Es sábado


Usando JSTL FOR



Patrón de diseño de Software MVC

El patrón Modelo Vista Controlador

El patrón MVC nos permite separar:
  • La lógica de control (las funcionalidades del proyecto)
  • La lógica de negocio (como se llevarán a cabo esas funcionalidades)
  • La lógica de presentación (cómo interactúa el usuario con el proyecto)

Utilizando patrón de separación en capas es posible conseguir:
  • Mayor calidad en el producto a desarrollar.
  • Un mantenimiento más sencillo y por ende menos costoso (recordemos que es la etapa del ciclo de vida más costosa).
  • Partir de un modelo base. 
  • Normalizar y estandarizar el desarrollo de Software.

Esto es gracias a que:
  • Existe una bien marcada separación entre los componentes (capas) de un programa; lo cual permite implementar estos por separado.
  • Existen varios Frameworks como JSF, Spring MVC, etc. que permiten reemplazar el modelo, la vista o el controlador, sin demasiada dificultad. Incluso sin un Framework es relativamente sencillo cambiar uno de los componentes del MVC sin afectar a los demás.
  • La conexión entre la capa de modelo y la capa que contiene las vistas es dinámica, pues se produce en tiempo de ejecución, no de compilación.

Ejemplo de aplicación con JAVA Web

En el lenguaje Java, específicamente un proyecto web dinámico tendríamos las siguientes consideraciones.
  • Model: el lenguaje SQL impera sobre el java.
  • Controller: el lenguaje java impera
  • View: el lenguaje HTML impera


La capa de la vista: La capa de persistencia (modelo) La capa de control

 
 


Adicionalmente tenemos:
Bibliotecas externas Bibliotecas internas Clases o entidades