Mostrando entradas con la etiqueta Servlet. Mostrar todas las entradas
Mostrando entradas con la etiqueta Servlet. Mostrar todas las entradas

miércoles, 17 de junio de 2020

Mostrar imágenes en JSP con Servlet

Consideramos la clase "Espacios" que proviene de la siguiente estructura SQL (Se ha obviado intencionalmente a la clave foránea en el campo "tipo"):
-- -----------------------------------------------------
-- Table espacios
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS espacios (
  idespacios INT NOT NULL AUTO_INCREMENT,
  piso TINYINT NOT NULL,
  precio DOUBLE(6,2) NOT NULL,
  ubicacion VARCHAR(25) NULL,
  tipo TINYINT NULL,
  imagen BLOB NULL,
  PRIMARY KEY (idespacios)
  )
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8;


Su clase en Java con el patrón DTO sería:
package dto;

public class Espacios {

    private Integer idespacios;
    private Integer piso;
    private Double precio;
    private String ubicacion;
    private Integer tipo;
    private byte[] imagen;

    public Espacios() {
    }

    /* Métodos Setter y getter */

}


El atributo imagen no se emplea, pero será de utilidad si convertimos el proyecto a uno de escritorio.
Su Interfaz e implementación DAO son:
package dao;

import java.util.List;
import dto.Espacios;

public interface DaoEspacios {

    public byte[] espaciosImg(Integer id);

    public String getMessage();
}

package dao.impl;

import biblioteca.ConectaBD;
import dao.DaoEspacios;
import dto.Espacios;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class DaoEspaciosImpl implements DaoEspacios {

    private final ConectaBD conectaDb;
    private String mensaje;

    public DaoEspaciosImpl() {
        this.conectaDb = new ConectaBD();
    }

    @Override
    public byte[] espaciosImg(Integer id) {
        byte[] img = null;
        StringBuilder sql = new StringBuilder();
        sql.append("SELECT ")
                .append("imagen")
                .append(" FROM espacios WHERE idespacios = ?");
        try (Connection cn = conectaDb.conexionDB()) {
            PreparedStatement ps = cn.prepareStatement(sql.toString());
            ps.setInt(1, id);
            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) {
                    Blob blob = rs.getBlob(1);
                    if (blob != null) {
                        byte[] bytes = blob.getBytes(1, (int) blob.length());
                        blob.free();
                        img = bytes;
                    }
                } else {
                    img = null;
                }
            } catch (SQLException e) {
                mensaje = e.getMessage();
            }
        } catch (SQLException e) {
            mensaje = e.getMessage();
        }
        return img;
    }

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


El servlet que permite mostrar la imagen sería:
package web.servlet;

import biblioteca.DeString;
import dao.DaoEspacios;
import dao.impl.DaoEspaciosImpl;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(name = "ImagenServlet", urlPatterns = {"/Imagen"})
public class ImagenServlet extends HttpServlet {

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("image/jpg");
        DaoEspacios daoEspacios = new DaoEspaciosImpl();
        Integer id = DeString.aInteger(request.getParameter("id"));
        try {
            byte[] data = daoEspacios.espaciosImg(id);
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            output.write(data, 0, data.length);
            response.setContentLength(output.size());
            try (OutputStream out = response.getOutputStream()) {
                output.writeTo(out);
                out.flush();
            }
        } catch (IOException ex) {
            System.err.println(String.format("%s - %s", daoEspacios.getMessage(), ex.getMessage()));
        }
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    @Override
    public String getServletInfo() {
        return "Short description";
    }
}


El URL para mostrar una imagen sería por ejemplo: http://localhost:8084/Demo/Imagen?id=8 donde el valor que cambia es el número "8" por el "id" del registro del que se desea mostrar la imagen.

Ejemplo:

Dentro de un JSP el código tendría la siguiente forma:

      <img src="Imagen?id=8" alt="img"/>
   


Ese valor 8 se puede reemplazar con código de manera que recibe el "id" esperado como en esta porción de código que captura el id mediante una estructura que lista todos los espacios con JSTL.

      <img src="Imagen?id=${f.idespacios}" alt="img"/>
   




sábado, 28 de marzo de 2020

Contenedor Web

Un contenedor web es el encargado de administrar el ciclo de vida de los Servlets en las aplicaciones Java EE, asignar una URL a cada uno de estos en particular. Además, se encarga de garantizar quienes requieren del Servlet mediante la URL tengan los derechos de acceso correctos.

Un contenedor web en esta perspectiva se encarga de manejar solicitudes de los Servlets y de los archivos de páginas de servidor Java (JSP). Además, administra las solicitudes de archivos que incluyen código del lado del servidor.

Un contenedor web crea instancias de Servlet, mediante la carga y descarga de servlets, creando y gestionando objetos de solicitud y respuesta.


Como se aprecia en la imagen, una típica forma de aplicaciones Java EE, donde existe un repositorio de datos que la Aplicación Java EE emplea para generar una vista al cliente. Podemos ver en este caso el todo.

Los Contenedores Web o "Web Container" están dentro del servidor. El servidor se encarga de manejar los pedidos y respuestas HTTP, dentro de este. El contenedor web se encarga de la comunicación del Servlet y los JSP. Como se aprecia en la siguiente imagen.




Se aprecia en la imagen que el cliente realiza una petición a través claro de la interfaz del programa que puede ser un JSP, este instancia a la capa de modelo (que podría ser un DAO) y realiza operaciones con la fuente de datos dependiendo de la petición y se carga información en el JSP que es posteriormente mostrado al cliente.



jueves, 17 de octubre de 2019

Servlets

¿Qué es un Servlet?

Se le llama así a una de las tecnologías proporcionadas por Java que generan componentes independientes que serán empleados en aplicaciones web, estos tienen acceso completo a las API de Java y las bibliotecas de HTTP. Los servlets están intimanente ligados a la plataforma y el servidor.

¿Cómo crear un Servlet en NetBeans?

Seguir los pasos:


¿Qué debemos modificar?

Cambiar el nombre de acuerdo a la función que hará o tabla que dará mantenimiento, colocarlo por preferencia en un paquete que contendrá a los servlets, en algunos casos podemos llamarlos controllers haciendo referencia al patrón MVC.

Modificar el alias del Servlet a uno que no incluya la terminación servlet y finalizar.


Código de ejemplo

Teniendo como base a la tabla "Inquilinos"(clic aquí para ver el DTO) a la que le realizaremos un mantenimiento (CRUD) teniendo como DAO a "DaoInquilinos" y su correspondiente implementación (clic aquí para ver el DAO).Además, las pruebas a las funciones declaradas en el DAO (clic aquí para ver el DAO).

Crearemos dos paquetes dentro del paquete web que serán "servlet" y "validator", dentro crearemos respectivamente el servlet llamado "InquilinosServlet" y una clase de apoyo llamada "InquilinosValidator", esta untima clase nos sirve para reducir la cantidad de código en el Servlet y poder tener mejor mantenimiento de este, por lo tanto es opcional.

Tendríamos el código de "InquilinosValidator" considerando las funciones que declaramos en el DAO, de la siguiente forma:
package web.validator;

import biblioteca.DeString;
import dao.DaoInquilinos;
import dao.impl.DaoInquilinosImpl;
import dto.Inquilinos;
import java.time.LocalDate;
import java.util.List;
import javax.servlet.http.HttpServletRequest;

public class InquilinosValidator {

    private final HttpServletRequest request;
    private final DaoInquilinos daoInquilinos;

    public InquilinosValidator(HttpServletRequest request) {
        this.request = request;
        this.daoInquilinos = new DaoInquilinosImpl();
    }

    public String inquilinosSel() {
        String result = null;
        List<Inquilinos> list = daoInquilinos.inquilinosSel();
        if (list != null) {
            request.setAttribute("list", list);
        } else {
            result = daoInquilinos.getMessage();
        }
        return result;
    }

    public String inquilinosGet() {
        String result = null;
        Integer idinquilino = DeString.aInteger(request.getParameter("idinquilino"));
        Inquilinos inquilino = daoInquilinos.inquilinosGet(idinquilino);
        if (inquilino != null) {
            request.setAttribute("inquilino", inquilino);

        } else {
            result = daoInquilinos.getMessage();
        }
        return result;
    }

    public String inquilinosInsUpd(boolean upd) {
        StringBuilder result = new StringBuilder("<ul>");
        Integer idinquilino = DeString.aInteger(request.getParameter("idinquilinos"));
        String dni = request.getParameter("dni");
        String nombres = request.getParameter("nombres");
        String paterno = request.getParameter("paterno");
        String materno = request.getParameter("materno");
        String telefono = request.getParameter("telefono");
        LocalDate fecha_ingreso = LocalDate.parse(request.getParameter("fecha_ingreso"));
        String correo = request.getParameter("correo");
        Double deuda = DeString.aDouble(request.getParameter("deuda"));
        if (upd && idinquilino == null) {
            result.append("<li>Id requerido</li>");
        }
        if (nombres == null || nombres.trim().length() == 0) {
            result.append("<li>Nombre requerido</li>");
        } else if (nombres.trim().length() < 3 || nombres.trim().length() > 50) {
            result.append("<li>La dimensión del nombre debe estar entre")
                    .append("3 a 50 caracteres</li>");
        }
        if (paterno == null || paterno.trim().length() == 0) {
            result.append("<li>Apellido paterno requerido</li>");
        } else if (paterno.trim().length() < 3 || paterno.trim().length() > 50) {
            result.append("<li>La dimensión del apellido paterno debe estar entre")
                    .append("3 a 50 caracteres</li>");
        }
        if (materno == null || materno.trim().length() == 0) {
            result.append("<li>Apellido materno requerido</li>");
        } else if (materno.trim().length() < 3 || materno.trim().length() > 50) {
            result.append("<li>La dimensión del apellido materno debe estar entre")
                    .append("3 a 50 caracteres</li>");
        }
        if (fecha_ingreso == null) {
            result.append("<li>Fecha requerida</li>");
        }
        if (deuda < 0d) {
            result.append("<li>La deuda no puede ser negativa</li>");
        }
        Inquilinos inquilino = new Inquilinos();
        inquilino.setIdinquilinos(idinquilino);
        inquilino.setDni(dni);
        inquilino.setNombres(nombres);
        inquilino.setPaterno(paterno);
        inquilino.setMaterno(materno);
        inquilino.setFecha_ingreso(fecha_ingreso);
        inquilino.setTelefono(telefono);
        inquilino.setDeuda(deuda);
        inquilino.setCorreo(correo);
        if (result.length() == 4) {
            String msg = upd
                    ? daoInquilinos.inquilinosUpd(inquilino)
                    : daoInquilinos.inquilinosIns(inquilino);
            if (msg != null) {
                result.append("<li>").append(msg).append("</li>");
            }
        }
        if (result.length() > 4) {
            request.setAttribute("inquilino", inquilino);
        }
        return result.length() == 4 ? null : result.append("</ul>").toString();
    }

    public String inquilinosDel() {
        List<Integer> ids = DeString.ids(request.getParameter("ids"));
        String result = (ids != null)
                ? daoInquilinos.inquilinosDel(ids)
                : "IDs incorrectos";
        return result;
    }
}

Mientras el código del Servlet sería:

package web.servlet;

import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import web.validator.InquilinosValidator;

@WebServlet(name = "InquilinosServlet", urlPatterns = {"/Inquilinos"})
public class InquilinosServlet extends HttpServlet {

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");

        String accion = request.getParameter("accion");
        accion = (accion == null) ? "" : accion;
        String result;
        String target = "inquilinosSel.jsp";

        InquilinosValidator validator = new InquilinosValidator(request);

        switch (accion) {
            case "SEL":
                result = validator.inquilinosSel();
                break;
            case "INS":
                result = validator.inquilinosInsUpd(false);
                target = result == null ? "inquilinos.jsp" : "inquilinosIns.jsp";
                break;
            case "DEL":
                result = validator.inquilinosDel();
                target = "inquilinos.jsp";
                break;
            case "GET":
                result = validator.inquilinosGet();
                target = "inquilinosUpd.jsp";
                break;
            case "UPD":
                result = validator.inquilinosInsUpd(true);
                target = result == null ? "inquilinos.jsp" : "inquilinosUpd.jsp";
                break;
            case "":
                result = "Solicitud requerida";
                break;
            default:
                result = "Solicitud no reconocida";
        }

        if (result != null) {
            request.setAttribute("message", result);
        }

        RequestDispatcher dispatcher = request.getRequestDispatcher(target);
        dispatcher.forward(request, response);
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    @Override
    public String getServletInfo() {
        return "Short description";
    }

}

La estructura de carpetas resultaría en:

La clase DeString es una librería interna. (clic aquí para ver el código), esta permite convertir String a Integer y Double, incluso en colecciones tipo List.