Ejecutar JSPs almacenados en Base de Datos

0
34474

Ejecución de JSP almacenado en una Base de Datos

Uno de los mensajes en nuestro foro, pregunta algo interesante:

¿Como interpretar código JSP almacenado en la base de datos?

Debemos entender la dinámica de los JSPs….

Un JSP posee normalmente HTML (aunque podríamos usarlo para generar XML, rdf,
etc. ) y código Java (denominado Scriptlet). También
podría contener, casi con toda seguridad si tenemos un conocimiento medio, etiquetas de usuario (custom
tags
) o de alguno de los conjuntos estándar (Struts,
JSTL,
etc..).

Cuando construimos un JSP, este se compila en un Servlet. Esta compilación no
es compleja, pero no tiene sentido que nos pongamos a construir compiladores ..

Podemos revisar en Internet la documentación relativa a include de JSPs, por
ejemplo en 

http://java.sun.com/products/jsp/syntax/1.1/syntaxref1112.html

<jsp:include page="{relativeURL | <%= expression %>}" flush="true" />

De un modo sencillo, podemos incluir dinámicamente otro JSP, donde el nombre
lo podemos obtener dinámicamente.

Si queremos ejecutar un JSP almacenado en la base de datos, solo tenemos que
preocuparnos que ese JSP exista físicamente.

Una posible solución podría ser crear un Java Beans sencillo que nos permita
generar el fichero físico (recuperándolo de la base de datos) al mismo tiempo
que retorne un nombre de fichero único.

Vamos a hacerlo.. aunque con estas ideas y otro de nuestros tutoriales, donde
os mostrábamos

como construir una aplicación con JSPs
, debería ser suficiente.

Contrucción del Ejemplo

Primero vamos a crear el proyecto en NetBeans (vamos deprisa porque en el
tutorial mencionado podéis ver todas las capturas con más detalles).

Le asignamos un directorio de trabajo y usando el Wizard, decimos que el
directorio sea un modulo Web

Y seleccionamos nuestro trayecto

Ahora creamos nuestro JSP

Le asignamos un nombre

Creamos el Bean en un paquete

le asignamos nombre

Y usamos el Wizard para crear el Bean

Le asignamos nombre

Añadimos nuestro método

Asignamos nombre, parámetros y valor de retorno

Modificamos el Java Bean (solo nos hace falta una línea), aunque nos sobra
mucho código generado automáticamente …

  /*
 * beanjspdinamico.java
 *
 * Created on April 18, 2004, 1:02 PM
 */

package roberto;

import java.beans.*;

/**
 *
 * @author  Roberto Canales
 */
public class beanjspdinamico extends Object implements java.io.Serializable {
    
    private static final String PROP_SAMPLE_PROPERTY = "SampleProperty";
    
    private String sampleProperty;
    
    private PropertyChangeSupport propertySupport;
    
    /** Creates new beanjspdinamico */
    public beanjspdinamico() {
        propertySupport = new PropertyChangeSupport( this );
    }
    
    public String getSampleProperty() {
        return sampleProperty;
    }
    
    public void setSampleProperty(String value) {
        String oldValue = sampleProperty;
        sampleProperty = value;
        propertySupport.firePropertyChange(PROP_SAMPLE_PROPERTY, oldValue, sampleProperty);
    }
    
    
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        propertySupport.addPropertyChangeListener(listener);
    }
    
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        propertySupport.removePropertyChangeListener(listener);
    }
    
    public String retornaJSPBBDD(int id) {
        
        return "ficherodinamico" + id + ".jsp";
        
    }
   
}

Creamos en el directorio base un JSP estático para probar nuestra teoría y lo
llamamos

ficherodinamico1.jsp

<% for (int i=0;i<5;i++)
{
%>
<br> Si ves esto es que funciona
<%
}
%>
 

Vemos como queda en la estructura de ficheros

Construimos nuestro JSP principal (gestordinamico.jsp)

<%@page contentType="text/html"%>
<html>
<head><title>JSP Page</title></head>
<body>

<jsp:useBean id="mibean" scope="session" class="roberto.beanjspdinamico" /> 

<center>

<h1>Soy el JSP principal</h1>

<jsp:include page="<%= mibean.retornaJSPBBDD(1) %>" flush="true" />

</center>
</body>
</html>
 

Y vemos el resultado ….

Es decir… ahora solo tenemos que modificar el código del método del JSP
para que, en función del parámetro, recupere de la base de datos el texto que
represente el JSP y lo escriba en un fichero físico….

Creamos la tabla en BBDD

Creamos la tabla en la base de datos (como casi siempre, jugamos con MySQL).
Podeir revisar algunos de los tutoriales que tenemos que os ensaña como

trabajar con Java y MySql

Creamos los campos

Le asignamos un nombre

Insertamos un registro en  nuestra tabla

Modificamos el método del Bean.  

Lo vamos a hacer del modo más simple, aunque no el más optimo … (no
usaremos pool de conexiones para no perder el objetivo). Tenéis varios
tutoriales en este Web que os enseñan

como configurar y utilizar pooles de conexiones
.

Creamos un primer método auxiliar para recuperar el texto en base al ID del
JSP dinámico en base de datos

    String ejecuta(String consultaGenerada)
    {
        
        String resultado = null;
        depura("Empezamos");

        Connection con = null;
        
        // REGISTER DRIVER
        try
        {
            Driver d = (Driver)Class.forName("com.mysql.jdbc.Driver").newInstance();

            depura("Recuperamos conexión");
            con = DriverManager.getConnection("jdbc:mysql://localhost/test","",""); 

            depura("Ejecutamos Statment");
            java.sql.Statement stmt = con.createStatement();
            
            depura("Ejecutamos sentencia " + consultaGenerada);
            ResultSet results = stmt.executeQuery(consultaGenerada);
            
            results.next();
            
            return results.getString(1);
        }
        catch (Exception e)
        {
            System.out.println(e);
            e.printStackTrace();
        }
        finally
        {
            try{
            if (con != null)
            {
                con.close();
            }
            }catch(Exception e){}
        }
        
        return resultado;
    } 

Creamos una función se sea capaz de escribir el fichero

   void generaFichero(String nombreFichero, String contenido)
    {
        String pathbase = "c:\\ejemplos\\jspdin\\"; // esto se debe recuperar usando patrones de diseño
        
        try
        {
            FileWriter escritor = new FileWriter(pathbase + nombreFichero,false);
            escritor.write(contenido);
            escritor.close();
        }
        catch(Exception e)
        {
            depura("Error al escribir fichero " + e);
        }
    }   

Y por último, el propio método…

   public String retornaJSPBBDD(int id) {
        
        String resultado =  retornaJSP(1);
        String nombreFichero =  "ficherodinamico" + id + ".jsp";
        
        depura (resultado);
        
        generaFichero(nombreFichero,resultado);
        
        return nombreFichero;
        
    }
    
      public String retornaJSP(int id) {
        return ejecuta("select jsp from jspdinamico where id = " + id);
    }

No se nos puede olvidar incluir en el directorio de librerías el driver JDBC
de MySQL.

Con todo esto, ejecutamos y …..

Sencillo verdad ….. Os podéis descargar el código
en este enlace … listo para funcionar .

Yo también repasaría el tutorial donde os enseñábamos como
ejecutar código java sin compilarlo (Añadir
Scripting a programas Java
)…. Este código también podría estar en base de
datos.

Ya tenemos una posible base que nos incita a plantearnos como
funcionan algunos gestores de contenidos ….. aunque esto …. es otra historia
….

Este ejemplo podría mejorarse optimizando el rendimiento con
caches (para no generar cuando no sea necesario), construyendo una
administración gráfica de los JSPs en base de datos (para saber cuando liberar
caches), etc

 

Sobre el
Autor ..

DEJA UNA RESPUESTA

Por favor ingrese su comentario!

He leído y acepto la política de privacidad

Por favor ingrese su nombre aquí

Información básica acerca de la protección de datos

  • Responsable:
  • Finalidad:
  • Legitimación:
  • Destinatarios:
  • Derechos:
  • Más información: Puedes ampliar información acerca de la protección de datos en el siguiente enlace:política de privacidad