Programador Java Web

Ejemplo de uso de Webservices y Ireport – Tienda Online

2012-02-12T05:07:00.000-08:00

Con todo lo que sabemos hasta ahora podemos crear una tienda online. Puesto que el código necesario es muy extenso para ponerlo en esta entrada, lo podeis descargar aquí y abrirlo con vuestro netbeans.
El proyecto se divide en 4 proyectos, que serán:

Webservice de Usuarios
Webservice de Productos
Webservice de Pedidos
Proyecto cliente

Y la base de datos es la siguiente:

usuarios
idusuarios INT(11) PK y AI
nombre VARCHAR(45)
apellidos VARCHAR(45)
direccion VARCHAR(45)
cp VARCHAR(45)
localidad VARCHAR(45)
provincia VARCHAR(45)
pais VARCHAR(45)
telefono VARCHAR(45)
alias VARCHAR(45)
email VARCHAR(45)
password VARCHAR(45)
rol TINYINT(4)
activado TINYINT(4)

productos
idproductos INT(11) PK y AI
nombre VARCHAR(245)
descripción VARCHAR(500)
stock INT(11)
precio DOUBLE
rutaFoto VARCHAR(245)

compra
idcompra INT(11) PK y AI
idUsuario INT(11)

pedidos
idpedidos INT(11)
unidades INT(11)
idProducto INT(11)
fecha VARCHAR(45)
estado VARCHAR(45)
idpedidos es foreign key que hace referencia a la tabla compra

IReport – Creador de informes

2012-02-12T05:00:00.000-08:00

iReport es una herramienta visual que sirve para generar ficheros XML (plantillas de informe) que se puedan utilizar con la herramienta de generación de informes JasperReports. Por ejemplo, cuando se esta programando una tienda online, se puede usar el iReport para poder generar las facturas. Vamos a ver los pasos a seguir para hacer este caso:

En primer lugar hay que bajarse las librerías de Jasper (jasperreports-4.5.0-project.tar.gz)aquí y el propio editor de informe iReport aquí.

En nuestro ejemplo, queremos crear un informe a partir del resultado de una consulta en nuestra base de datos. La base de datos se llama tienda y tiene las tablas compra, pedidos, productos y usuarios.

Ejecutamos el iReport y creamos un archivo nuevo. Elegimos la plantilla y pulsamos Launch Report Wizard. Ahí seleccionamos el lugar donde se van a guardar los archivos y en el siguiente paso debemos darle a New en el apartado de Connections/Data Sources. Seleccionamos Database JDBC connection, se configuran los parámetros de la base de datos y luego escribes la consulta, por ejemplo:

SELECT idcompra,idusuarios,alias,idproductos,productos.`nombre`,unidades,precio,fecha
FROM `productos` productos INNER JOIN `pedidos` pedidos ON productos.`idproductos` = pedidos.`idProducto`,
`usuarios` usuarios INNER JOIN `compra` compra ON usuarios.`idusuarios` = compra.`idUsuario`
WHERE idcompra = idpedidos AND idcompra = 7

Puesto que la factura se generará según el id de la compra, en la consulta ponemos un valor cualquiera (7) pero después añadiremos ese parámetro como variable.
Le damos a siguiente, añadimos todos los parámetros y le damos a terminar. Se abrirá nuestro report. Ahora vamos a añadir ese parámetro que dije antes. Pulsamos con el botón derecho sobre nuestro report y seleccionamos Edit Query. Ahí aparecerá nuestra consulta, y donde ponía 7 ahora habría que cambiarlo por $P{idcompra}. Le damos a OK, y , estando otra vez en la pantalla principal, pulsamos el botón derecho sobre Parameters y añadimos uno llamado idcompra. Hecho esto podemos probar el resultado dándole a Preview.

Ya esta terminado nuestro informe. Ahora hay que usarlo en nuestro código. Al finalizar se ha generado un archivo .jrxml y otro .jasper. Estos se deben copiar en nuestro proyecto, dentro de webpages. Ahora creamos un jsp en el proyecto llamado report.jsp, que contendrá el siguiente código:

<%@page import="java.util.Map"%>
<%@page import="java.util.HashMap"%>
<%@ page language="java" import="net.sf.jasperreports.engine.*,net.sf.jasperreports.engine.export.*" %>
<%@ page import="java.sql.*,java.io.*" %>
<%
 String filename = request.getParameter("filename");
 String reporttype = request.getParameter("reporttype");
Class.forName("com.mysql.jdbc.Driver").newInstance();

 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/tienda", "root", "forman");

 System.out.println("Connection Established");
 String path = application.getRealPath("/");

 Map parameters = new HashMap();
 parameters.put("idcompra",request.getParameter("idcompra"));
 JasperPrint jasperPrint = JasperFillManager.fillReport(path + "/" + filename, parameters, conn);

 System.out.println("Report Created...");
OutputStream ouputStream = response.getOutputStream();
JRExporter exporter = null;
if ("pdf".equalsIgnoreCase(reporttype)) {
 response.setContentType("application/pdf");
 exporter = new JRPdfExporter();
 exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
 exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, ouputStream);
 } else if ("rtf".equalsIgnoreCase(reporttype)) {
 response.setContentType("application/rtf");
 response.setHeader("Content-Disposition", "inline; filename=\"file.rtf\"");
exporter = new JRRtfExporter();
 exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
 exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, ouputStream);
 } else if ("html".equalsIgnoreCase(reporttype)) {
 exporter = new JRHtmlExporter();
 exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
 exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, ouputStream);
 } else if ("xls".equalsIgnoreCase(reporttype)) {
 response.setContentType("application/xls");
 response.setHeader("Content-Disposition", "inline; filename=\"file.xls\"");
exporter = new JRXlsExporter();
 exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
 exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, ouputStream);
 } else if ("csv".equalsIgnoreCase(reporttype)) {
 response.setContentType("application/csv");
 response.setHeader("Content-Disposition", "inline; filename=\"file.csv\"");
exporter = new JRCsvExporter();
 exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
 exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, ouputStream);
 }
try {
 exporter.exportReport();
 } catch (JRException e) {
 throw new ServletException(e);
 } finally {
 if (ouputStream != null) {
 try {
 ouputStream.close();
 } catch (IOException ex) {
 }
 }
 }
%>

En él habrá que cambiar la configuración de nuestra base de datos (color naranja) y el/los parametro/s que hayamos puesto en la consulta (color rojo), si no hay parámetros se pone null (color verde).
Ahora hay que descomprimir el archivo que descargamos anteriormente con todas las librerías. Se añade al proyecto el jasperreport-4.5.0.jar y después todas los .jar que hay en la carpeta lib.
Por último queda llamar a nuestro jasper. Imaginemos que en la tienda online, cuando el usuario confirma el pedido, le aparece un link donde mostrarle un pdf con la factura de su pedido. En el código de este link sería:

%>
 <p style="color:green">Pedido tramitado correctamente. Nos pondremos en contacto con usted para informarle de todo el proceso. Puede ver su factura <a href="report.jsp?filename=report2.jasper&reporttype=pdf&paramID=<%=request.getAttribute("idCompra").toString()%>">aquí</a>.</p>
 <%

En el verde hay que poner el report que creamos y en el rojo ponemos el parámetro que creamos y su valor.

Web Services

2012-02-12T04:57:00.000-08:00

Un servicio web es una pieza de software que utiliza un conjunto de protocolos y estándares que sirven para intercambiar datos entre aplicaciones. Distintas aplicaciones de software desarrolladas en lenguajes de programación diferentes, y ejecutadas sobre cualquier plataforma, pueden utilizar los servicios web para intercambiar datos en redes de ordenadores como Internet. Las ventajas de los web services son:

Aportan interoperabilidad entre aplicaciones de software independientemente de sus propiedades o de las plataformas sobre las que se instalen.
Los servicios Web fomentan los estándares y protocolos basados en texto, que hacen más fácil acceder a su contenido y entender su funcionamiento.
Permiten que servicios y software de diferentes compañías ubicadas en diferentes lugares geográficos puedan ser combinados fácilmente para proveer servicios integrados.

Ahora vamos a ver un ejemplo de uso de servicios web, haciendo el ejemplo de login de usuario:

Primero tenemos que crear el servicio web de usuarios, el cual va a contener todas las funciones correspondientes al usuario, en nuestro caso solo el login (aunque también estarían las funciones de registrar usuario, borrarlo, modificarlo, etc). Este servicio web hará uso de la clase Usuario, que es la que realmente contiene las funciones. Dicho esto, tenemos que crear un nuevo proyecto en Netbeans llamado Usuarios Webservice (New Project -> Java Web -> Web application). En el pondremos la clase MySQL que ya vimos en anteriores entradas y la clase Usuario, que contiene el siguiente código:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
/**
 *
 * @author Tarde
 */
public class Usuario {
 //ATRIBUTOS
 private int id;
 private String nombre;
 private String apellidos;
 private String direccion;
 private String cp;
 private String localidad;
 private String provincia;
 private String pais;
 private String telefono;
 private String alias;
 private String email;
 private String password;
 private int rol;
 private int activado;
public Usuario(){
}
//CONSTRUCTORES
 public Usuario(String alias,String password){
 this.alias=alias;
 this.password=password;
 }
public Usuario(String nombre, String apellidos, String direccion, String cp, String localidad, String provincia, String pais, String telefono, String alias, String email, String password, int rol, int activado) {
 this.nombre = nombre;
 this.apellidos = apellidos;
 this.direccion = direccion;
 this.cp = cp;
 this.localidad = localidad;
 this.provincia = provincia;
 this.pais = pais;
 this.telefono = telefono;
 this.alias = alias;
 this.email = email;
 this.password = password;
 this.rol = rol;
 this.activado = activado;
 }
//METODOS
/**
 * @return the id
 */
 public int getId() {
 return id;
 }
/**
 * @param id the id to set
 */
 public void setId(int id) {
 this.id = id;
 }
/**
 * @return the nombre
 */
 public String getNombre() {
 return nombre;
 }
/**
 * @param nombre the nombre to set
 */
 public void setNombre(String nombre) {
 this.nombre = nombre;
 }
/**
 * @return the apellidos
 */
 public String getApellidos() {
 return apellidos;
 }
/**
 * @param apellidos the apellidos to set
 */
 public void setApellidos(String apellidos) {
 this.apellidos = apellidos;
 }
/**
 * @return the direccion
 */
 public String getDireccion() {
 return direccion;
 }
/**
 * @param direccion the direccion to set
 */
 public void setDireccion(String direccion) {
 this.direccion = direccion;
 }
/**
 * @return the cp
 */
 public String getCp() {
 return cp;
 }
/**
 * @param cp the cp to set
 */
 public void setCp(String cp) {
 this.cp = cp;
 }
/**
 * @return the localidad
 */
 public String getLocalidad() {
 return localidad;
 }
/**
 * @param localidad the localidad to set
 */
 public void setLocalidad(String localidad) {
 this.localidad = localidad;
 }
/**
 * @return the provincia
 */
 public String getProvincia() {
 return provincia;
 }
/**
 * @param provincia the provincia to set
 */
 public void setProvincia(String provincia) {
 this.provincia = provincia;
 }
/**
 * @return the pais
 */
 public String getPais() {
 return pais;
 }
/**
 * @param pais the pais to set
 */
 public void setPais(String pais) {
 this.pais = pais;
 }
/**
 * @return the telefono
 */
 public String getTelefono() {
 return telefono;
 }
/**
 * @param telefono the telefono to set
 */
 public void setTelefono(String telefono) {
 this.telefono = telefono;
 }
/**
 * @return the alias
 */
 public String getAlias() {
 return alias;
 }
/**
 * @param alias the alias to set
 */
 public void setAlias(String alias) {
 this.alias = alias;
 }
/**
 * @return the email
 */
 public String getEmail() {
 return email;
 }
/**
 * @param email the email to set
 */
 public void setEmail(String email) {
 this.email = email;
 }
/**
 * @return the password
 */
 public String getPassword() {
 return password;
 }
/**
 * @param password the password to set
 */
 public void setPassword(String password) {
 this.password = password;
 }
/**
 * @return the rol
 */
 public int getRol() {
 return rol;
 }
/**
 * @param rol the rol to set
 */
 public void setRol(int rol) {
 this.rol = rol;
 }
/**
 * @return the activado
 */
 public int getActivado() {
 return activado;
 }
/**
 * @param activado the activado to set
 */
 public void setActivado(int activado) {
 this.activado = activado;
 }
public int login(){
 int existe=0;
 try{
 MySQL mysql=new MySQL("tienda","//localhost","root", "forman");
mysql.inicializarBD();
//consulta
 mysql.consultar("SELECT idusuarios,rol FROM usuarios WHERE alias='"+alias+"' AND password='"+password+"' AND activado=1;");
 //ejecutar la consulta
 ResultSet rst = mysql.getResultSet();
if(rst.next()){ //Existe
 existe=1;
 id=rst.getInt("idusuarios");
 }else{ //No existe
 id=-1;
 }
 mysql.cerrarBD();
}catch(SQLException err){
 System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
 }finally{
 return id;
 }
 }
}

Ahora sí, creamos el servicio web. Para ello le damos al segundo botón del ratón sobre nuestro proyecto, y elegimos New -> Web Service . Le damos nombre UsuarioWS y le especificamos el mismo paquete donde se han guardado las otras clases. En este nuevo archivo que se ha creado, se pueden añadir las funciones escribiendo el código manualmente, o mediante el Design, que es una pestaña que aparece en la parte de arriba. Como se ha dicho, este web service se limitará a llamar a la clase usuario y a la función login:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org;
import java.sql.SQLException;
import java.util.ArrayList;
import javax.jws.WebService;
import javax.jws.WebMethod;
import javax.jws.WebParam;
/**
 *
 * @author Tarde
 */
@WebService(serviceName = "UsuarioWS")
public class UsuarioWS {
/** This is a sample web service operation */

 @WebMethod(operationName = "login")
 public int login(String alias,String password) {
 Usuario usu=new Usuario(alias,password);
 int id=usu.login();
 return id;
 }
}

Hecho esto, ya tenemos la funcionalidad del usuario lista. Ahora se debe compilar y después hacer el ‘Test Web Service’ al archivo UsuarioWS que esta en la carpeta que se generó ‘Web Services’. Se abrirá una nueva ventana en el navegador donde aparecerán las funciones de ese servicio web. Es muy importante comprobar que todo funciona correctamente, antes de que un cliente haga uso de este webservice, que es nuestro siguiente paso.

Imaginemos que este es un proyecto muy grande y el trabajo esta dividido en varios departamentos. En tu departamento, te han asignado la tarea de hacer el servicio web de usuarios y que funcione correctamente. En otro departamento, la tarea que tienen es hacer un aplicación cliente, que haga uso de este webservice. Esta es una de las ventajas de los servicios web: este departamento lo único que tiene que saber es que funciones contiene el servicio web y que parámetros se les pasa, y ellos podrán usarlas como quieran, incluso con lenguajes y arquitectura distintas.

En la aplicación cliente (que será un nuevo proyecto) se tiene que añadir el webservice. Para ello se hace click en el segundo botón New -> Web Service Client. Aquí se añade el proyecto Usuario Webservice creado anteriormente, y se empaqueta en un paquete distinto llamado wsUsuario.

El código del cliente tendría un formulario de usuario y contraseña, que cuando se rellena manda al servlet que es el que hará uso de la función login del servicio web. Para añadir esta función al código hay que pulsar con el segundo botón sobre el código y darle a Insert Code -> Call Web Service Operation, y seleccionar la función login. Ahora en el código habría que usar esta llamada. Se quedaría así:

package org;
import java.io.IOException;
import java.io.PrintWriter;
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 javax.servlet.http.HttpSession;
import javax.xml.ws.WebServiceRef;
import wsUsuario.UsuarioWS_Service;
/**
 *
 * @author Tarde
 */
@WebServlet(name = "IniciarSesionServlet", urlPatterns = {"/IniciarSesionServlet"})
public class IniciarSesionServlet extends HttpServlet {
 @WebServiceRef(wsdlLocation = "WEB-INF/wsdl/localhost_8080/Ejercicio_4.2._-_Usuarios_WebService/UsuarioWS.wsdl")
 private UsuarioWS_Service service_1;
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
 protected void processRequest(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
 response.setContentType("text/html;charset=UTF-8");
 PrintWriter out = response.getWriter();
 try{
 ResultSet rst;
 String alias,password;
alias=request.getParameter("txtNombre");
 password=request.getParameter("txtPassword");

 //Encriptacion del password
 StringBuffer passwordEncriptado=Encriptar.encripta(password);

 int id=login(alias,passwordEncriptado.toString());
HttpSession sesion=request.getSession(true);
 if(id!=-1){ //Existe
 sesion.setAttribute("idLogeado", id);
 sesion.setAttribute("nombreLogeado", alias);

request.getRequestDispatcher( "/index.jsp" ).forward( request, response );
 }catch(Exception ex){

 }
 }
 // <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
 /**
 * Handles the HTTP <code>GET</code> method.
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
 @Override
 protected void doGet(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
 processRequest(request, response);
 }
/**
 * Handles the HTTP <code>POST</code> method.
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
 @Override
 protected void doPost(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
 processRequest(request, response);
 }
/**
 * Returns a short description of the servlet.
 * @return a String containing servlet description
 */
 @Override
 public String getServletInfo() {
 return "Short description";
 }// </editor-fold>
private int login(java.lang.String arg0, java.lang.String arg1) {
 wsUsuario.UsuarioWS port = service_1.getUsuarioWSPort();
 return port.login(arg0, arg1);
 } 
}

Uso de XML, serializar y deserializar

2012-02-12T04:54:00.000-08:00

XML es un lenguajes de modelado de datos o, lo que es lo mismo, es un lenguaje que permite definir un modelo de datos. Se podría decir que es un fichero que guarda los datos como si fuera una base de datos y se utiliza cuando se necesite. Se puede usar para que una aplicación use datos de otra, como un RSS. Por ejemplo, un archivo xml sería:

<?XML>
<clientes>
  <usuario>
    <nombre>Juan</nombre>
  </usuario>
</cliente>

SAX es una librería estandar en Java que permite el manejo de archivos para serializar y deserializar los ficheros XML. Estos dos conceptos se definirían de esta forma:

Serialización: Coge objetos de memoria y los registra en un fichero físico.
Deserialización: Lee el fichero interpretando los nodos y los pasa a objetos.(continuar, poniendo código de serialización y deserialización)

Veamos ahora un ejemplo:

Tenemos una web, donde se suben imágenes y los usuarios las votan. Queremos que, cada vez que un usuario vota, en un archivo XML se guarden las 5 más votadas para luego mostrarlas. Para ello, en primer lugar necesitamos la clase Imagen:

package ria;
/**
 *
 * @author Tarde
 */
public class Imagen {
 //ATRIBUTOS
 private int id;
 private String nombre;
 private String ruta;
 private String descripcion;
 private int votos;

 public Imagen(){

 }
 public Imagen(String nombre,String ruta,String descripcion,int votos){
 this.nombre=nombre;
 this.ruta=ruta;
 this.descripcion=descripcion;
 this.votos=votos;

 }
/**
 * @return the id
 */
 public int getId() {
 return id;
 }
/**
 * @param id the id to set
 */
 public void setId(int id) {
 this.id = id;
 }
/**
 * @return the nombre
 */
 public String getNombre() {
 return nombre;
 }
/**
 * @param nombre the nombre to set
 */
 public void setNombre(String nombre) {
 this.nombre = nombre;
 }
/**
 * @return the ruta
 */
 public String getRuta() {
 return ruta;
 }
/**
 * @param ruta the ruta to set
 */
 public void setRuta(String ruta) {
 this.ruta = ruta;
 }
/**
 * @return the descripcion
 */
 public String getDescripcion() {
 return descripcion;
 }
/**
 * @param descripcion the descripcion to set
 */
 public void setDescripcion(String descripcion) {
 this.descripcion = descripcion;
 }
/**
 * @return the votos
 */
 public int getVotos() {
 return votos;
 }
/**
 * @param votos the votos to set
 */
 public void setVotos(int votos) {
 this.votos = votos;
 }

 public int subirImagen(){
 int s;
 MySQL mysql=new MySQL("flickr","//localhost","root", "forman");
 mysql.inicializarBD();
 s=mysql.insertar("INSERT INTO imagenes (nombre,ruta,descripcion,votos,idUsuario) VALUES ('"+getNombre()+"','"+getRuta()+"','"+getDescripcion()+"','0','"+getId()+"');");
 mysql.cerrarBD();

 return s;
 }
}

También necesitamos la clase que va a serializar las imagenes (ImagenSerializator.java). En esta se especifica que imágenes va a contener el XML, que son el resultado de una consulta:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ria;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;
import com.sun.org.apache.xml.internal.serialize.OutputFormat;
import com.sun.org.apache.xml.internal.serialize.XMLSerializer;
import java.sql.ResultSet;
import java.sql.SQLException;
import ria.MySQL;
/**
 *
 * @author Tarde
 */
public class ImagenSerializator {
 String path;
 List myData;
 Document dom;

 public ImagenSerializator(String path) {
 myData = new ArrayList();
 this.path = path;
 init();
 createDocument();
 }
 private void init(){
 try{
 MySQL mysql=new MySQL("flickr","//localhost","root","forman");
 ResultSet rs;
 mysql.inicializarBD();
 mysql.consultar("SELECT nombre,ruta,descripcion,votos FROM imagenes ORDER BY votos DESC LIMIT 5");
 rs=mysql.getResultSet();
 while(rs.next()){
 myData.add(new Imagen(rs.getString("nombre"),rs.getString("ruta"), rs.getString("descripcion"),rs.getInt("votos")));
 }
 }catch(SQLException ex){

 }

 }
 private void createDocument() {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 try {
 DocumentBuilder db = dbf.newDocumentBuilder();
dom = db.newDocument();
}catch(ParserConfigurationException pce) {
 System.out.println("Error while trying to instantiate DocumentBuilder " + pce);
 System.exit(1);
 }
 }

 public void createDOMTree(){
Element rootEle = dom.createElement("galeria");
 dom.appendChild(rootEle);
Iterator it = myData.iterator();
 while(it.hasNext()) {
 Imagen b = (Imagen)it.next();
Element ImagenEle = createImagenElement(b);
 rootEle.appendChild(ImagenEle);
 }

 }

 private Element createImagenElement(Imagen b){
Element ImagenElem = dom.createElement("imagen");
 //StockEle.setAttribute("id", b.getID());
Element nombreElem = dom.createElement("nombre");
 Text nombreText = dom.createTextNode(b.getNombre());
 nombreElem.appendChild(nombreText);
 ImagenElem.appendChild(nombreElem);
Element rutaElem = dom.createElement("ruta");
 Text rutaText = dom.createTextNode(b.getRuta());
 rutaElem.appendChild(rutaText);
 ImagenElem.appendChild(rutaElem);
Element descripcionElem = dom.createElement("descripcion");
 Text descripcionText = dom.createTextNode(b.getDescripcion());
 descripcionElem.appendChild(descripcionText);
 ImagenElem.appendChild(descripcionElem);

 Element votosElem = dom.createElement("votos");
 Text votosText = dom.createTextNode(String.valueOf(b.getVotos()));
 votosElem.appendChild(votosText);
 ImagenElem.appendChild(votosElem);
return ImagenElem;
}
public void Serialization(){
try
 {
 OutputFormat format = new OutputFormat(dom);
 format.setIndenting(true);
XMLSerializer serializer = new XMLSerializer(
 new FileOutputStream(new File(path + "/galeriaMIO.xml")), format);
serializer.serialize(dom);
} catch(IOException ie) {
 ie.printStackTrace();
 }
 }
}

Ahora, cuando se quiera crear el archivo XML, es decir, cuando el usuario vota, se llamaría a serializar.jsp, que contiene el siguiente código:

<%@page import="ria.ImagenSerializator"%>
<%
//Context Path
String path = application.getRealPath("/");
//Instance
ImagenSerializator stockSer = new ImagenSerializator(path);
//Prepare tree
stockSer. createDOMTree();
//Save to file
stockSer.Serialization();
request.getRequestDispatcher( "/index.jsp" ).forward( request, response );
%>

El archivo XML se guarda por defecto build/web, dentro del proyecto.

Ahora, cuando el usuario quiera ver el top five de imágenes más votadas, deserializará este XML y lo mostrará en pantalla. Para ello haremos uso de dos clases que guardarán cada uno de los elementos del XML y lo dejarán listos para poder manipularlos. A estas clases no es necesario que le hagas ningún cambio, simplemente añádelas a tu proyecto y listo:

MyElement.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ria;
import org.xml.sax.Attributes;

public class MyElement implements java.io.Serializable {

 String uri;
 String localName;
 String qName;
 String value=null;

 Attributes attributes;

 public MyElement() {}

 public MyElement(String uri, String localName, String qName, Attributes attributes) {
 this.uri = uri;
 this.localName = localName;
 this.qName = qName;
 this.attributes = attributes;
 }

 public String getUri() {
 return uri;
 }

 public String getLocalName() {
 return localName;
 }

 public String getQname() {
 return qName;
 }

 public Attributes getAttributes() {
 return attributes;
 }

 public String getValue() {
 return value;
 }

 public void setValue(String value) {
 this.value = value;
 }

}

MySAXParseBean.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ria;
import java.io.*;
import java.util.*;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
public class MySAXParseBean extends DefaultHandler implements java.io.Serializable {
 private String text;
 private Vector vector = new Vector();
 private MyElement current = null;

 public MySAXParseBean() {}

 public Vector parse(String filename) throws Exception {

 SAXParserFactory spf = SAXParserFactory.newInstance();
 spf.setValidating(false);

 SAXParser saxParser = spf.newSAXParser();

 // create an XML reader
 XMLReader reader = saxParser.getXMLReader();

 FileReader file = new FileReader(filename);

 // set handler
 reader.setContentHandler(this);

 // call parse on an input source
 reader.parse(new InputSource(file));

 return vector;
 }

 // receive notification of the beginning of an element
 public void startElement (String uri, String name, String qName, Attributes atts) {

 current = new MyElement(uri, name, qName, atts);

 vector.addElement(current);
 text = new String();
 }

 // receive notification of the end of an element
 public void endElement (String uri, String name, String qName) {

 if(current != null && text != null) {
 current.setValue(text.trim());
 }
 current = null;

 }

 // receive notification of character data
 public void characters (char ch[], int start, int length) {

 if(current != null && text != null) {
 String value = new String(ch, start, length);
 text += value;
 }
 }

}

Y ya por último, en verTopFive.jsp, se mostrarán las imágenes y sus votos, haciendo uso de MyElement:

<%@page import="ria.MySQL"%>
<%@page import="java.sql.ResultSet"%>
<%@page import="ria.ImagenSerializator"%>
<%@page import="ria.MyElement"%>
<%@ page import="java.util.*" %>
<%@ page import="org.*" %>
<html>
<head>
<title>Top Five Galeria</title>

</head>

<body>
 <jsp:useBean id="saxparser" class="ria.MySAXParseBean" />

<%
HttpSession sesion=request.getSession(false);
if(sesion.getAttribute("idLogeado")!=null){
 String idLogeado=sesion.getAttribute("idLogeado").toString();
 int iniciado=1;
 String path = application.getRealPath("/");
 Collection stocks = saxparser.parse(path + "galeriaMIO.xml");
Iterator ir = stocks.iterator();
 //mysql.consultar("SELECT idimagenes,nombre,ruta,descripcion,votos,idUsuario FROM imagenes;");
 //rst=mysql.getResultSet();
 %>

<h3>Top 5</h3>
 <table border="1">
 <tr>
 <td>
 <h4>Imagen</h4>
 </td>
 <td>
 <h4>Votos</h4>
 </td>
 <td></td>
 <td></td>
</tr>
 <tr>
 <%
 int contador=0;
 while(ir.hasNext()) {
 MyElement element = (MyElement) ir.next();
 String tag = element. getQname();

 if(tag.equals("ruta")) { %>
<td>
 <img src="./imagenes/<%= element.getValue() %>" >

 </td>
 <%
 } else if (tag.equals("votos")) {
 %>
 <td>
 <%= element.getValue() %>
 </td>
 </tr>
 <%
 }
 }

 %>
 </table>

 <a href="index.jsp">Volver</a>
 <%
}else{
 %>
 No estas logeado para entrar en esta página. <a href="index.jsp">Inicia sesión</a>
 <%
 }
 %>

 </body>
</html>

Colecciones

2012-02-12T04:50:00.001-08:00

El lenguaje Java pone a nuestra disposición, gracias a la API Collections, una serie de clases destinadas a la creación de estructuras de datos. Existen 6 tipos:

Collection: Esta interface representa un grupo general de objetos, donde es posible que el grupo contenga objetos duplicados.
Set: No hay elementos repetidos. Puede estar o no ordenada. (HashSet y LinkedHashSet).
SortedSet: Conjunto de elementos en orden ascendente natural o definido por un objeto Comparator (TreeSet).
List: El orden de los elementos es relevante. Puede tener elementos repetidos. (ArrayList, LinkedList y Vector).
Map: Estructura de datos en parejas clave/valor, lo que permite localizar un valor en función de una clave dada (HashMap y Hashtable).
SortedMap: Elementos en orden ascendente natural o definido por un objeto Comparator (TreeMap).

Veamos ahora más detenidamente, las clases más utilizadas:

ArrayList – Listas indexadas:

Es la implementación de un array redimensionable de la interface List. Implementa operaciones de listado. Permite valores null. También provee métodos para manipular el tamaño del array que se utiliza internamente para guardar la lista.

Cada instancia del ArrayList tiene una capacidad. La capacidad es el tamaño del array utilizado para guardar los elementos en la lista. Es, como mínimo, del tamaño de la lista. Conforme se agregan elemento al ArrayList, su capacidad crece automáticamente.

Antes de utilizar la clase ArrayList es necesario realizar el import correspondiente:

import java.util.ArrayList;

Para crear un nuevo ArrayList utilizamos el siguiente código:

ArrayList lista = new ArrayList();

Si se desea recorrer el contenido del ArrayList, utilizamos un iterador:

Iterator i_lista = lista.iterator();
//Mientras que el iterador tenga un proximo elemento
while( i_lista.hasNext() ) {
System.out.println(iter.next());
}

Recordar que se debe realizar el import del Iterator para que pueda ser utilizado:

import java.util.Iterator;

LinkedList – Listas enlazadas

LinkedList, al igual que ArrayList es una implementación de la interface List. Implementa operaciones de listado. Además de implementar la interface List, esta clase provee métodos para obtener (get), eliminar(remove) e insertar (insert) elementos al principio y fin de la lista. Estas operaciones permiten a las listas enlazadas ser utilizadas como una pila (stack), o colas doblemente enlazadas.

Es importante mencionar que una lista enlazada es una estructura posicional, es decir, que importa donde estas situado en cada momento. Al método add de la lista añade el elemento al final de la lista, para colocarlo en una posición determinada debes usar un Iterator.

Utilizamos el siguiente import para utilizar la clase LinkedList:

import java.util.LinkedList;

Para declarar un objeto de tipo LinkedList lo hacemos de la siguiente manera:

LinkedList nombre = new LinkedList ();

Para agregar un elemento a la LinkedList lo hacemos de la siguiente manera:

nombre.add(elemento);

Por ejemplo:

Lista.add(“Elemento 1”);

Si deseamos recorrer el contenido de la LinkedList, lo hacemos a través de un iterador. Siempre recordar que se debe incluir el import:

import java.util.Iterator;

y con el siguiente código recorremos los elementos:

Iterator i_linkedlist = linked_list.iterator();
//Mientras que el iterador tenga un proximo elemento
while( i_linkedlist.hasNext() ) {
System.out.println(i_linkedlist.next());
}

Hashset – conjuntos indexados

Esta clase implementa la interface Set, en conjunto con una table hash(actualmente es una instancia a HashMap). Este tipo de clase no garantiza que los elementos van a permanecer ordenados durante su uso. Permite elementos null.

Esta clase ofrece un funcionamiento constante para las operaciones básicas (add, remove, contains y size).

Esta implementación no se encuentra sincronizada. Esto quiere decir que si múltiples hilos acceden a colocar elemento concurrentemente, y al menos uno de esos elementos modifica el Set, debe ser sincronizado externamente.

En el siguiente ejemplo se mostrará como manipular elementos utilizando un HashSet. Estos conjuntos de datos tienen la propiedad de que no se pueden guardar dos elementos con el mismo valor.

El import para la clase HashSet es el siguiente:

import java.util.HashSet;

Primero creamos nuestro objeto de tipo HashSet:

Set hs = new HashSet();

Luego cargamos el conjunto de datos:

hs.add("Erick");
hs.add("Byron");
hs.add("Byron"); // Los elementos solo pueden estar una vez
hs.add("Gerson");

Cuando se agrega un elemento repetido (Byron), este elemento solo aparecerá 1 vez.

Para recorrer nuestro objeto debemos implementar un iterador:

Iterator i_hs = hs.iterator();

Utilizando el método .next() nos movemos a través del iterador:

while (iter.hasNext())
System.out.println(iter.next());

Treeset – Árboles

Esta clase implementa la interface Set, basada en una instancia de TreeMap. Esta clase garantiza que el ordenamiento de los elementos será en orden ascendente, ordenando de acuerdo al orden natural de los elementos, o por el comparador dado en el momento de creación, dependiendo de qué constructor se utilice.

Esta implementación provee método del tipo agregar, eliminar y contiene (contains).

Esta implementación al igual que Hashset, no está sincronizada.

La clase TreeSet es muy similar a la anterior, Hashset, con la diferencia de que esta vez los elementos sí están ordenados. Esta estructura es el típico árbol binario que todos conocemos. El rendimiento es inferior al de los conjuntos indexados, aunque aquí los elementos siempre están ordenados y en algunos casos el rendimiento es mucho mejor que un Array o una lista ordenada.

Antes de utilizar esta clase debe hacerse el siguiente import:

import java.util.TreeSet;

Para crear un nuevo objeto de tipo TreeSet se implementa el siguiente código:

TreeSet lista2 = new TreeSet();

Si se desea agregar elementos, se utiliza el método add de la siguiente manera:

hs.add("Elemento 1");
hs.add("Elemento 2");

Los elementos que agreguemos pueden ser de cualquier tipo. Para el ejemplo, aquí agregamos objetos de tipo String.

Al igual que las clases explicadas anteriormente, para recorrer los elementos de un objeto de Tipo TreeSet se utiliza un iterador:

Iterator i_hs = ts.iterator();

Y mediante el método .hasNext() accedemos a los elementos:

while (iter.hasNext())
System.out.println(iter.next());

Podcast – Herencia en Java

2012-02-09T07:13:00.001-08:00

Esto es un podcast hecho por mi, que explica en que consiste la herencia en Java y donde además se citan los aspectos más importantes que hay que saber sobre la herencia para los exámenes de certificado (minuto 8:05). También se citan una serie de preguntas tipo test (minuto 11:40). En entradas posteriores, podrás encontrar el guión de este podcast.

Feed Podcast- Herencia en Java
Tambien lo puedes descargar aquí.

Subir ficheros y registrarlos en la base de datos

2012-02-08T07:34:00.000-08:00

Este es el código para poder subir ficheros al servidor y registrarlos en la base de datos. Se necesita añadir al proyecto las siguientes librerías:
http://commons.apache.org/fileupload/
http://commons.apache.org/io/

Tener en cuenta que a partir de la entrada anterior, todos los ejemplos aparecerá con el código modularizado. Por ejemplo, en este ejemplo existe una clase Imagen que contiene todos las funciones y métodos que manipulen las imágenes. En este código aparece el formulario para subir imagen al servidor, y una vez subida, aparecerá el formulario para darle nombre y descripción:

subirImagen.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Subir imagen</title>
 </head>
 <body>
 <%
 HttpSession sesion=request.getSession(false);
 if(sesion.getAttribute("idLogeado")!=null){

 %>
 <h1>Subir imagen</h1>
 <form method="post" enctype='multipart/form-data' action="subirImagenServlet">
 Por favor, seleccione fichero a subir<br/>
 <input type="file" name="fichero" /> 
 <input type="submit" />
 </form>
 <%
 if(request.getAttribute("subido")!=null){
 if(request.getAttribute("subido").toString().equals("true")){
 %>
 <p style="color: green">Fichero subido correctamente.</p>
 <%
 if(request.getAttribute("rutaFichero")!=null){
 %>
 <form method="post" action="subirDatosImagenBeans.jsp">
 <label>Nombre:</label>
 <input type="text" id="txtNombreImagen" name="nombre">
 <br>
 <label>Ruta: <%=request.getAttribute("rutaFichero")%></label>
 <input type="hidden" id="txtRuta" name="ruta" value="<%=request.getAttribute("rutaFichero")%>">
 <br>
 <label>Descripción:</label>
 <input type="text" id="txtDescripcion" name="descripcion">
 <input type="hidden" id="txtId" name="id" value="<%=sesion.getAttribute("idLogeado").toString()%>">

 <input type="submit" id="idEnviar" value="Enviar">
 </form>
 <%
 }
 }else{
 %>
 <p style="color: red">Error al subir fichero.</p>
 <%
 }
 }
 if(request.getAttribute("errorInsercion")!=null){
 if(request.getAttribute("errorInsercion").toString().equals("1")){
 %>
 <p style="color: green">Imagen insertada correctamente.</p>
 <%
 }else{
 %>
 <p style="color: red">Error al insertar imagen en la base de datos.</p>
 <%
 }
 }
 %>
 <a href="index.jsp">Volver</a>
 <%
 }else{
 %>
 No esta logeado para entrar en esta página. <a href="index.jsp">Inicia sesión</a>
 <%
 }
 %>

 </body>
</html>

subirImagenServlet.java
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ria;
import java.io.IOException;
import java.io.PrintWriter;
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 java.io.*;

import javax.servlet.*;
import javax.servlet.http.*;

import org.apache.commons.fileupload.*;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import java.util.*;
/**
 *
 * @author Tarde
 */
@WebServlet(name = "subirImagenServlet", urlPatterns = {"/subirImagenServlet"})
public class subirImagenServlet extends HttpServlet {
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
 protected void processRequest(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
 // si se quiere comprobar que es un request de ficheros
 //boolean isMultipart = ServletFileUpload.isMultipartContent(request);
 response.setContentType("text/html");
 PrintWriter out = response.getWriter();

 boolean flag = false;
 String fileName = "";
 List fileItems = null;
 String path = getServletContext().getRealPath("/")+"imagenes/";
 String rutaFichero="";

 try {
 // construimos el objeto que es capaz de parsear la perición
 DiskFileItemFactory factory = new DiskFileItemFactory(); 

 // tamaño por encima del cual los ficheros son escritos directamente en disco
 factory.setSizeThreshold(4096);
 // directorio en el que se escribirán los ficheros con tamaño superior al soportado en memoria
 factory.setRepository(new File(path + "/"));

 // nuevo manejador para el fichero
 ServletFileUpload upload = new ServletFileUpload(factory);
 // maximo numero de bytes
 upload.setSizeMax(1024*512);
 // ordenamos procesar los ficheros
 fileItems = upload.parseRequest(request);
 if (fileItems == null) {
 flag=false;
 }
 // Iteramos por cada fichero
 Iterator i = fileItems.iterator();
 FileItem actual = null;

 if (i.hasNext()) {

 actual = (FileItem) i.next();
 fileName= actual.getName(); 

 // construimos un objeto file para recuperar el trayecto completo
 File fichero = new File(fileName);
 // nos quedamos solo con el nombre y descartamos el path
 fichero = new File(path + fichero.getName());
 // escribimos el fichero colgando del nuevo path
 actual.write(fichero);

 flag = true;
 rutaFichero=fichero.getName();
 }
 } catch (Exception e) {
 out.println(e.getMessage());
 }

 //////////////////////////////////////////////////////////////////////////////////////

 request.setAttribute("rutaFichero",rutaFichero);
 request.setAttribute("subido", flag);
 request.getRequestDispatcher( "/subirImagen.jsp" ).forward( request, response );

 out.close();
 }
// <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
 /**
 * Handles the HTTP <code>GET</code> method.
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
 @Override
 protected void doGet(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
 processRequest(request, response);
 }
/**
 * Handles the HTTP <code>POST</code> method.
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
 @Override
 protected void doPost(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
 processRequest(request, response);
 }
/**
 * Returns a short description of the servlet.
 * @return a String containing servlet description
 */
 @Override
 public String getServletInfo() {
 return "Short description";
 }// </editor-fold>
}
subirDatosImagenBeans.jsp
<jsp:useBean id="imagen" class="ria.Imagen"/>
<jsp:setProperty name="imagen" property="*" />
<%@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>
 <%
 int s=imagen.subirImagen();
 request.setAttribute("errorInsercion", s);
 request.setAttribute("subido", "true");
 request.getRequestDispatcher( "/subirImagen.jsp" ).forward( request, response );
 %>
 </body>
</html>
Imagen.java
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ria;
/**
 *
 * @author Tarde
 */
public class Imagen {
 //ATRIBUTOS
 private int id;
 private String nombre;
 private String ruta;
 private String descripcion;
 private int votos;

 public Imagen(){

 }
 public Imagen(String nombre,String ruta,String descripcion,int votos){
 this.nombre=nombre;
 this.ruta=ruta;
 this.descripcion=descripcion;
 this.votos=votos;

 }
/**
 * @return the id
 */
 public int getId() {
 return id;
 }
/**
 * @param id the id to set
 */
 public void setId(int id) {
 this.id = id;
 }
/**
 * @return the nombre
 */
 public String getNombre() {
 return nombre;
 }
/**
 * @param nombre the nombre to set
 */
 public void setNombre(String nombre) {
 this.nombre = nombre;
 }
/**
 * @return the ruta
 */
 public String getRuta() {
 return ruta;
 }
/**
 * @param ruta the ruta to set
 */
 public void setRuta(String ruta) {
 this.ruta = ruta;
 }
/**
 * @return the descripcion
 */
 public String getDescripcion() {
 return descripcion;
 }
/**
 * @param descripcion the descripcion to set
 */
 public void setDescripcion(String descripcion) {
 this.descripcion = descripcion;
 }
/**
 * @return the votos
 */
 public int getVotos() {
 return votos;
 }
/**
 * @param votos the votos to set
 */
 public void setVotos(int votos) {
 this.votos = votos;
 }

 public int subirImagen(){
 int s;
 MySQL mysql=new MySQL("flickr","//localhost","root", "forman");
 mysql.inicializarBD();
 s=mysql.insertar("INSERT INTO imagenes (nombre,ruta,descripcion,votos,idUsuario) VALUES ('"+getNombre()+"','"+getRuta()+"','"+getDescripcion()+"','0','"+getId()+"');");
 mysql.cerrarBD();

 return s;
 }
}

Modularización – Clase envoltorio para operaciones de BBDD

2012-02-08T07:16:00.000-08:00

La modularización es un elemento clave en la programación orientada a objetos. Modularizar un proyecto consiste en ordenar los objetos(clases, atributos, métodos…) de forma que pueda ser más fácil de usar y entender para el resto de grupo de trabajo. Aquí juega un papel muy importante las clases envoltorio (Wrapper), las cuales engloban toda la funcionalidad de esa clase, por ejemplo, la clase Float, Integer, etc.

En los ejercicios de entradas anteriores, se usaban muchas funciones que manipulan la base de datos. Lo más útil sería hacer una clase que contenga todos las funciones que hacen uso de la base de datos. Este es el código que crea la clase MySQL:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org;
import java.sql.Statement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
 *
 * @author Tarde
 */
public class MySQL {
 //ATRIBUTOS
 private Connection conn=null;
 private Statement stm=null;
 private ResultSet rst;
 private String bbdd="";
 private String ruta="";
 private String usuario="";
 private String password="";

 //CONSTRUCTOR
 public MySQL(String bbdd,String ruta,String usuario,String password){
 this.bbdd=bbdd;
 this.ruta=ruta;
 this.usuario=usuario;
 this.password=password;
 }

 public ResultSet getResultSet(){
 return this.rst;
 }

 public void inicializarBD(){
 try {
 //crear el driver
 Class.forName("com.mysql.jdbc.Driver").newInstance();
 //obtener el manejador
 // localhost, que en este caso es "prueba",
 //el usuario mysql es admin la password es adminadmin
 conn=DriverManager.getConnection("jdbc:mysql:"+ruta+"/"+bbdd,usuario,password);
//obtener el statement
 stm= conn.createStatement(); 

 }catch(SQLException err){
System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
}catch(Exception e){
System.out.println(e.getMessage());
}
 }

 public void cerrarBD(){
 try {
 stm.close();
 if (conn!=null){
 conn.close();
 } 

 }catch(SQLException err){
System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
}catch(Exception e){
System.out.println(e.getMessage());
}
 }

 public void consultar(String consulta){

 if(!consulta.equals("")){
 try{
 rst = stm.executeQuery(consulta);
 }catch(SQLException err){
 System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
 }catch(Exception e){
 System.out.println(e.getMessage());
 }
 }
 }

 public int insertar(String consulta){

 int s=-1;

 try{
 if(!(consulta.equals(""))){
 s = stm.executeUpdate(consulta);
 }
 }catch(SQLException err){
System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
}catch(Exception e){
System.out.println(e.getMessage());
}finally{
 return s; //Si es -1 es error del método insertar

 }
 }

 public int actualizar(String consulta){

 int s=-1;

 try{
 if(!(consulta.equals(""))){
 s = stm.executeUpdate(consulta);
 }
 }catch(SQLException err){
System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
 s=-1;
}catch(Exception e){
System.out.println(e.getMessage());
 s=-1;
}finally{
 return s; //Si es -1 es error del método Actualizar

 }
 }

 public int borrar(String consulta){
 int s=-1;

 try{
 if(!(consulta.equals(""))){
 s = stm.executeUpdate(consulta);
 }
 }catch(SQLException err){
System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
}catch(Exception e){
System.out.println(e.getMessage());
}finally{
 return s;
 }
 }

 public int contar(String consulta){
 int s=-1;

 try{
 if(!(consulta.equals(""))){
 rst = stm.executeQuery(consulta);
 if(rst.next()){
 s=rst.getInt(1);
 }
 }
 }catch(SQLException err){
System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
}catch(Exception e){
System.out.println(e.getMessage());
}finally{
 return s;
 }
 }
}

Una vez hecho esto, ya se puede instanciar esta clase en el proyecto, para hacer diferentes tareas. Por ejemplo, para hacer el login, sería:

public int login(){
 int existe=0;
 try{
 MySQL mysql=new MySQL("flickr","//localhost","root", "forman");
mysql.inicializarBD();
//consulta
 mysql.consultar("SELECT idusuarios,rol FROM usuarios WHERE alias='"+alias+"' AND password='"+password+"' AND activado=1;");
 //ejecutar la consulta
 ResultSet rst = mysql.getResultSet();

 if(rst.next()){ //Existe
 existe=1;
 id=rst.getInt("idusuarios");
 }else{ //No existe
 id=-1;
 }
 mysql.cerrarBD();

 }catch(SQLException err){
 System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
 }finally{
 return id;
 }
 }

Manejo de excepciones

2012-02-07T09:37:00.001-08:00

Siempre que exista un código problemático (que sea susceptible a error) se debe incluir dentro de un try-catch, para que el error que pueda ‘arrojar’ este código, sea capturado y mostrado en pantalla como el usuario desee. A estos errores se le llaman excepciones. Hay excepciones de todo tipo y también se pueden crear unas propias para el proyecto. En este ejemplo se va a mostrar cómo crear una excepción personalizada, que se le lance cuando en un formulario, se inserte un producto que ya exista:

Primero se crea una clase excepción llamada ExcepcionProductoRepetido:

package org;

public class ExcepcionProductoRepetido extends Exception {
    ExcepcionProductoRepetido(){
        super(); // constructor por defecto de Exception
    }
    ExcepcionProductoRepetido( String cadena ){
        super( cadena ); // constructor param. de Exception
    }
}

Se crea la clase que lanzará la excepción (Lanzadora.java):

package org;
public class Lanzadora {
    public void siProductosIguales( int sonIguales ) throws ExcepcionProductoRepetido {
    if(sonIguales==1){
            throw new ExcepcionProductoRepetido( "Los productos están repetidos." );
        }

}
}

En la parte del código donde se inserta un producto en la base de datos:

...
try{
...
mysql.inicializarBD();
mysql.consultar("SELECT COUNT(nombre) AS COUNT FROM producto WHERE nombre='"+producto.getNombre()+"';");
rst=mysql.getResultSet();
if(rst.next()){
   if(!rst.getString("count").equals("0")){
        lanzaExcepcion.siProductosIguales(1);
   }
}
...
}catch(ExcepcionProductoRepetido er){
    out.println("Mi excepción: "+er.getMessage());
}

El resultado es que, si se crea un producto con el mismo nombre, aparecerá en pantalla el mensaje:

Mi excepción: Los productos están repetidos.

Envío de correo con JavaMail

2012-02-07T04:01:00.000-08:00

En una aplicación web profesional se suele usar el envío automático de email como un medio más para comunicar con el usuario. Por ejemplo, cuando se registra a un usuario, antes de que se guarde en la base de datos, la cuenta debe ser activada personalmente por este usuario, normalmente, entrando a un link que se le envía a su correo electrónico. Para el envío de JavaMails se puede usar tanto el servidor de correo donde está alojada la aplicación web, como cualquier proveedor de correo, como gmail. Aquí está el código necesario para enviar un email con una cuenta de gmail desde una aplicación Java:

//Envio del email para activar cuenta
int enviadoEmail;
// enter here the smtp mail server address
// ask your ISP to get the proper name
String mailServer ="smtp.gmail.com";
String username="carmaoone5@gmail.com";
String password="123aod12";

String fromEmail = "carmaoone5@gmail.com";
String toEmail = usuario.getEmail();
String messageEnter = "Hola "+usuario.getNombre()+", te has registrado en la web, pero para terminar el proceso tienes que activar tu cuenta pinchando en <a href='http://localhost:8080/Ejercicio_2.8._-_Catalogo/validacion.jsp?id="+idInsertado+"'>este enlace.</a>";

if (toEmail.equals("")) {
    toEmail = "unknown";
}

Properties props = new Properties();
props.put("mail.smtps.host", mailServer);
props.put("mail.smtp.auth", "true");
props.put("mail.smtps.port", "465");
props.put("mail.smtps.STARTTLS.enable", true);

Session o = Session.getInstance(props, null);

MimeMessage message = new MimeMessage(o);

InternetAddress from = new InternetAddress(fromEmail);
message.setFrom(from);

InternetAddress to = new InternetAddress(toEmail);

message.addRecipient(Message.RecipientType.TO, to);

message.setSubject("Validación de registro");
message.setText(messageEnter);

message.setContent(messageEnter, "text/html");

Transport tr = o.getTransport("smtps");
tr.connect(mailServer, username, password);

message.saveChanges(); // don't forget this
tr.sendMessage(message, message.getAllRecipients());
tr.close();

if (status == true) {
    enviadoEmail=1;
}

En rojo se muestra las variables que corresponden a la cuenta de gmail que va a enviar el email. En naranja aparece a quién va destinado el email (toEmail) y de quién es (fromEmail), además del mensaje que se envía. En verde aparece el código necesario para enviar el correo.

Las clases String, StringBuffer y StringBuilder – 2. Métodos

2012-02-07T03:52:00.000-08:00

La clases String, StringBuffer y StringBuilder tienen muchos métodos que permiten la manipulación de las cadenas. En la API de Java se pueden encontrar documentación sobre todos ellos. Aquí se muestra un resumen de los más significativos:

Métodos String:

char charAt(int index) .- Devuelve el carácter en la posición indicada por index. El rango de index va de 0 a length() – 1.
boolean equals(Object obj).- Compara el String con el objeto especificado. El resultado es true si y solo si el argumento es no nulo y es un objeto String que contiene la misma secuencia de caracteres.
boolean equalsIgnoreCase(String s).- Compara el String con otro, ignorando consideraciones de mayúsculas y minúsculas. Los dos Strings se consideran iguales si tienen la misma longitud y, los caracteres correspondientes en ambos Strings son iguales sin tener en cuenta mayúsculas y minúsculas.
int indexOf(char c).- Devuelve el indice donde se produce la primera aparición de c. Devuelve -1 si c no está en el string.

int indexOf(String s) .- Igual que el anterior pero buscando la subcadena representada por s.
int length() .- Devuelve la longitud del String (número de caracteres)
String substring(int begin, int end) .- Devuelve un substring desde el índice begin hasta el end (el end no incluido)
static String valueOf(int i) .- Devuelve un string que es la representación del entero i. Obsérvese que este método es estático. Hay métodos equivalentes donde el argumento es un float, double, etc.
char[] toCharArray()
String toLowerCase()
String toUpperCase() .- Transforman el string en un array de caracteres, o a mayúsculas o a minúsculas.

Métodos StringBuffer:

public StringBuffer append(char c) .- Añade el carácter c al valor del StringBuffer. Este método está sobrecargado varias veces recibiendo como parámetro otros tipos: String, Object, int, float, long…
public char charAt(int index) .- Devuelve el carácter de la posición index.
public int indexOf(int ch) .- Devuelve la primera ocurrencia de ch (-1 si no está).
public int length() .- Devuelve la longitud de la cadena de caracteres.
public int capacity() .- Devuelve el número de caracteres que puede contener sin necesidad de alocar mas memoria.
public String toString() .- Devuelve un String representado por el StringBuffer.
public String substring(int beginIndex) .- Devuelve un String desde beginIndex hasta el final.
public StringBuffer reverse() .- Devuelve la cadena invertida.
public void setCharAt(int index, char ch) .- Reemplaza el carácter de la posición index por ch.
public StringBuffer replace(int start, int end, String str) .- Reemplaza la cadena entre start y end con str.
public StringBuffer insert(int offset, char c) .- Inserta c en la posición offset de la cadena. Este método está sobrecargado varias veces recibiendo como parámetro a insertar otros tipos: int, float, long…
public StringBuffer delete(int start, int end) .- Elimina de los caracteres entre las posiciones start y end.

Javabeans

2012-02-06T06:46:00.000-08:00

Un Javabeans es una clase plana (POJO – Plain Old Java Objects) con atributos privados, constructor y métodos get y set. En JSP se usan para pasar datos de un lado a otro y sustituye a los servlets que se han visto en entradas anteriores, para hacer más claro y eficiente el código y contribuye a la separación entre lógica de negocio y presentación.
Por ejemplo, usando el ejemplo de inicio de sesión de usuarios que se vió en la agenda personal, el equivalente simplificado sería este:

Se crea un clase Javabean llamada Usuario.java. En ella se definen los atributos y los métodos get y set.

package org;

public class Usuario implements java.io.Serializable {
    private int id;
    private String nombre;
    private String email;
    private String clave;
    
    public int getId()
    {
        return id;
    }
    public void setId(int id){
        this.id=id;
    }
    
    public String getNombre()
    {
        return nombre;
    }
    public void setNombre(String nombre){
        this.nombre=nombre;
    }
    
    public String getEmail()
    {
        return email;
    }
    public void setEmail(String email){
        this.email=email;
    } 

    public String getClave()
    {
        return clave;
    }
    public void setClave(String clave){
        this.clave=clave;
    }

}

Después, en el index.jsp, se crea el formulario igual que en casos anterior. Los campos tienen que tener el mismo ‘name’ que el del atributo de la clase:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<jsp:useBean id="usuario" scope="session" />
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Inicio sesión</title>
</head>
<body>
  
 <div align="center" style="background-color:gainsboro">
     <form method="POST" action="IniciarSesionBeans.jsp" name="frm" id="idForm">
            <table style="background-color: gainsboro">
                <tr>
                    <td>
                        <label>Nombre:</label>
                    </td>
                    <td>
                        <input type="text" id="txtNombre" name="nombre"/>
                    </td>
                </tr>
                <tr>
                    <td>
                        <label>Password:</label>
                    </td>
                    <td>
                        <input type="password" id="txtPassword" name="clave"/>
                    </td>
                </tr>
                <tr align="right">
                    <td>
                        <input type="button" name="BtnEnviar" id="BtnEnviarId" value="ENVIAR" onclick="Validar();" />                        
                    </td>
                </tr>
            </table>
            </form>
 </div>
    </body>
</html>

En IniciarSesionBeans.jsp se va a usar el bean creado mediante el tag de acción: <jsp:useBean id=”usuario” scope=”session” />
Se usa la visibilidad ‘session’ para hacer que los atributos de usuario se puedan usar en cualquier parte del proyecto.
Mediante
<jsp:setProperty name=”usuario” property=”*” />
se obtiene todos los valores del formulario de index.jsp y se le asignan a los atributos de la clase usuario.

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@page import="java.sql.ResultSet"%>
<%@page import="java.sql.SQLException"%>
<%@page import="java.sql.DriverManager"%>
<%@page import="java.sql.Statement"%>
<%@page import="java.sql.Connection"%>
<%@page import="java.lang.String"%>
<%@page import="java.lang.Object"%>
<!DOCTYPE html>
<jsp:useBean id="usuario" scope="session" />
<jsp:setProperty name="usuario" property="*" />

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
     
        <%
        Connection conn=null;
        Statement stm= null;
        String nombre,password;
        
        try {
            nombre=usuario.getNombre();
            password=usuario.getClave();
            
            //crear el driver
            Class.forName("com.mysql.jdbc.Driver").newInstance(); 

            //obtener el manejador
            conn=DriverManager.getConnection("jdbc:mysql://localhost/banco", "root", "forman"); 

            //obtener el statement
            stm= conn.createStatement(); 

            String sql;
            //consulta
            sql="SELECT idusuario FROM usuario WHERE nombre='"+nombre+"' AND clave='"+password+"';";
            //ejecutar la consulta
            ResultSet rst = stm.executeQuery(sql);
            if(rst.next()){
                usuario.setId(Integer.parseInt(rst.getString("idusuario")));
                usuario.setNombre(nombre);
            }else{
                usuario.setId(-1);
            }
            request.getRequestDispatcher( "/index.jsp" ).forward( request, response );
            
             stm.close(); 

        }catch(SQLException err){ 

            System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
            

        }catch(Exception e){ 

            System.out.println(e.getMessage());
            

        }finally{ 

            //cerrar la conexion
            if (conn!=null){
                try{
                        conn.close();
                }catch(Exception e){}
            }
            out.close();
        }
        %>
      
    </body>
</html>

En rojo se puede ver como se obtienen los valores que se guardaron en los atributos de usuario desde el formulario. En naranja se muestra como establecer los atributos id y nombre a usuario, de forma que, como se puso scope=”session”, pueda ser utilizado en otros jsp del proyecto, simplemente poniendo al principio del código el <jsp:useBean id=”usuario” scope=”session” /> y recogiendo las varibles con usuario.getId().
Si no se pone scope=”session” los valores de los atributos del Javabean solo se podrán manipular dentro de ese mismo jsp.
Por último, cuando sea necesario cerrar la sesión y borrar todos las variables, se hace igual que en servlets:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<jsp:useBean id="usuario" scope="session" />
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <%
        usuario.setId(0);
        HttpSession sesion = request.getSession(false);
        sesion.invalidate();
        request.getRequestDispatcher( "/index.jsp" ).forward( request, response );
        %>
        
    </body>
</html>

Las clases String, StringBuffer y StringBuilder – 1. Introducción

2012-02-06T03:30:00.000-08:00

En Java no existe un tipo de datos primitivo que sirva para la manipulación de cadenas de caracteres. En su lugar se usa una clase definida en la API llamada String. Por lo tanto, las cadenas en Java se tratan como objetos. Debido a que este objeto se usa frecuentemete, existe soporte directo, con lo que simplificar alguna operaciones. Así, si se quiere crear una variable de tipo String, como objeto que es, se debe instanciar:

String s = new String("hola");

Aunque se puede hacer de forma directa:

String s = "hola";

Por otro lado, cuando a un String se le modifica el valor, la memoria que ocupaba éste no se reemplaza, sino que se borra y se crea una nueva zona de memoria (es una zona de memoria inmutable). Esto hace que si se modifica muchas veces la variable String se hace un mal uso de la gestión de la memoria.

Por eso, existen 2 clases más tipo String, definidas en la api, que permiten el uso de cadenas de forma variable, no constante, StringBuffer y StringBuilder.

StringBuffer sí es mutable, asi que cuando se cambia la cadena se mantiene la misma zona de memoria. Y StringBuilder, que tambien es mutable, pero no es thread-safe, es decir, que no esta prerparada para proceso multihilo, por lo que es más óptima.

En estas dos clases, para darle valor a la variable, sí es necesario instanciarlo:

StringBuffer s = new StringBuffer("Hola");

Ejemplo de uso de base de datos, paso de parámetros y sesiones – Agenda personal

2012-02-03T10:42:00.000-08:00

Una vez que ya se han visto en entradas anteriores cómo hacer uso de una base de datos, de cómo se pasan los parámetros de una página a otra y de cómo usar las sesiones, ha llegado el momento de ver un ejemplo que lo englobe todo. El ejemplo consiste en crear una agenda personal, de forma que un usuario se registe en la base de datos, y pueda crear, modificar o eliminar sus contactos. Solo cuando el usuario inicie sesión aparecerán sus contactos (y solo los suyos).
Las tablas necesarias en la base de datos sería la de usuarios(idusuarios,nombre,password,email) y contactos(idcontactos,nombre,telefono,email,idUsuario)
Aquí esta un documento adjunto con todo el código:
Ejemplo de uso Agenda personal
Y aquí la descripción de cada método:

index.jsp
La página principal mostrará el formulario de inicio de sesión y permitirá registrar. Si el usuario ya ha iniciado sesión, mostrará los contactos de su agenda
InicioSesionServlet.java
Este servlet recogerá los datos del formulario, y hará una consulta a la base de datos para ver si existe. Si es así, se crearán las variables de sesión y el usuario habrá iniciado sesión.
registro.jsp
Aquí el usuario rellena un formulario para registrarse. Tiene javascript para validar los campos. En caso de que ya exista el nombre de usuario se devolverá un error.
RegistrarUsuarioServlet.java
Este es el servlet al que llama registro.jsp. En el se toman las variables del formulario enviadas por método POST y se insertan en la base de datos con INSERT INTO.
insertarContacto.jsp
Aquí se muestra un formulario para crear un contacto del usuario dado por la variable de sesión.
InsertarContactoServlet.java
Es el que recoge los datos del formulario y los inserta en la base de datos.
buscar.jsp
Esta página se muestra cuando en la página principal, el usuario rellena el textbox del Buscar. Coge ese texto y lo busca en la base de datos usando LIKE y ORDER BY. Recorrerá el resultado de la consulta y los muestra.
modificar.jsp
A esta página le llegan los parámetros del contacto enviados por el index.jsp mediante el método GET, y lo muestra dentro de un formulario.
ModificarContactoServlet.java
Las modificaciones que se realicen se insertan en la base de datos mediante UPDATE.
BorrarContactoServlet.java
Toma mediante request.getParameter la variable dada por index.jsp y borra el contacto de la base de datos mediante DELETE.
cerrarSesion.jsp
Destruye todas las variables de sesión mediante invalidate().

Sesiones en Java

2012-02-02T10:06:00.000-08:00

En entradas anteriores se ha visto cómo se pasan parámetros de una página a otra. En una web en el que hay un sistema de registro de usuarios, cuando un usuario ha iniciado sesión y navega por sus diferentes páginas, cada una de las páginas debe tener acceso a los datos de ese usuario (id, nombre,…). Con los métodos GET y POST aprendidos anteriormente, en cada llamada a la página siguiente habría que ir pasando estos parámetros, lo que hace que todo se haga más lioso, con más líneas de código y menos óptimo. Por eso, para estos casos se hace uso de las variables de sesión, donde cada página podrá acceder a las variables globales de todo el proyecto.

Cuando un cliente solicita una URL al servidor, este reserva memoria para ese cliente y le da una id. A esta zona de memoria se le llama Sesión. Para activar esta zona de memoria, en el código de la web, en la página donde se logea el usuario, se usa:

HttpSession sesion=request.getSession(true);

Este código solo se escribe una vez en todo el proyecto. Para establecer las variables de la sesión se pondría:

sesion.setAttribute("nombre_de_variable",ValorDeVariable);

Para que en otra página se pueda recoger esa variable de sesión, se debe de poner en cada jsp o servlet que lo necesite:

HttpSession sesion=request.getSession(false);

Y despues se obtienen con:

sesion.getAttribute("nombre_de_variable");

Hay que tener en cuenta que la sesión guarda objetos. Para recoger esos objetos hay que hacerle un cast para tomarlo como el tipo de dato que se desee. Por ejemplo, si se quiere establecer una variable entero con valor 4, y despues se quiere obtener, sería haría así:

sesion.setAttribute("nombre_variable_entero",new Integer(4));
---...---
int variable_entero_que_recojo=(Integer) sesion.getAttribute("nombre_variable_entero");

O para el caso de querer usar una variable de sesión de tipo String:

sesion.setAttribute("nombre_variable_string", "valor_variable_string");
---...---
String varible_string_que_recojo=sesion.getAttribute("nombre_variable_string").toString();

Por último, cuando se cierre la sesión del usuario, se querrá borrar de memoria todas estas variables, para ello se usa:

sesion.invalidate;

Validar con Javascript

2012-02-02T07:07:00.001-08:00

Cuando el usuario rellena un formulario en una página web, éste se envía al servidor y hace las pertinentes operaciones con esos datos. Los datos que rellena el cliente deben ser validados, de forma que no mande campos en blanco o caracteres incorrectos. Para no saturar el servidor, lo correcto es que la validación se realice en el propio cliente. Para ello, se va a usar el lenguaje javascript. Este código tambien se descarga en el cliente junto al HTML.
Aquí hay un ejemplo de validación de un formulario, comprobando que el usuario no mande algun campo en blanco:

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Registro</title>
    <script>

     function Validar() { 

       if (document.getElementById("idNombre").value == "") {
           document.getElementById("spanErrorNombre").innerHTML = "<font color='red'>* Campo obligatorio</font>";
       }else{
           if (document.getElementById("idPassword").value == "") {
                document.getElementById("spanErrorPassword").innerHTML = "<font color='red'>* Campo obligatorio</font>";
            }else{
                if (document.getElementById("idMail").value == "") {
                    document.getElementById("spanErrorMail").innerHTML = "<font color='red'>* Campo obligatorio</font>";
                }else{  
                    document.frm.submit();
                }
            }
       }

    }
    </script>
    </head>
    <body>
     <div align="center" style="background-color:gainsboro">
         <form action="RegistrarUsuarioServlet" method="post" name="frm" id="idFrm">
         <table>
             <tr>
                 <td>
                     <h2>Registro de usuario</h2>
                 </td>
             </tr>
             <tr>
                 <td>
                       <label> Nombre: </label>
                 </td>
                 <td>
                       <input type="text" name="txtNombre" id="idNombre"/>
                 </td>
                 <td>
                       <span id="spanErrorNombre"></span>
                 </td>
             </tr>
             <tr>
                 <td>
                     <label> Password: </label>
                 </td>
                 <td>
                       <input type="password" name="txtPassword" id="idPassword"/>
                 </td>
                 <td>
                       <span id="spanErrorPassword"></span>
                 </td>
             </tr>
             <tr>
                 <td>
                       <label> E-mail: </label>
                 </td>
                 <td>
                       <input type="text" name="txtMail" id="idMail"/>
                 </td>
                 <td>
                       <span id="spanErrorMail"></span>
                 </td>
             </tr>
             <tr>
                 <td>
                       <input type="button" name="BtnEnviar" id="BtnEnviarId" value="ENVIAR" onclick="Validar();" />
                 </td>
             </tr>

             </table>
         </form>
</div>
    </body>
</html>

En rojo se marca las etiquetas que encuadran el código Javascript. Aquí se pone en la parte de arriba por hacerlo más visible, pero es recomendable ponerlo debajo de todo el HTML para hacer la compilación más óptima. Aunque si va a ser un código más extenso, con muchas funciones, lo mejor sería crear un archivo .jsp aparte y luego llamarlo en la página principal.
En naranja se muestra cómo desde el HTML se llama a la función que hay en el javascript. El input type=”Button” tiene muchos eventos que se pueden controlar, como el momento de pulsar el boton (onClick), el de pasar el raton por encima(onMouseOver), etc.

Lo que hace este código es obtener los valores de cada campo mediante el getElementById y, si estan vacíos, insertar HTML en el hueco definido con la etiqueta <span>, mostrando un mensaje de error. Siempre es mejor por eficiencia usar el getElementById antes que el getElementByName. Tener en cuenta tambien que a todos los elementos de la página web a los que se vaya a hacer referencia en códigos javascript o en servlets, siempre se deben identificar con el id y el name, ya que los archivos java (servlets) lo van a referenciar con el valor dado en name y los archivos de javascript, con el id.

Por último, decir que Javascript no tiene nada que ver con Java, son lenguajes distintos, se le nombró así por puro marketing.

Bases de datos en Java

2012-02-01T10:34:00.000-08:00

En este ejemplo se va a mostrar como crear una base de datos en MySQL y cómo acceder a sus datos desde una aplicación web Java.

Crear base de datos

En primer lugar hay que instalar MySQL Server http://dev.mysql.com/downloads/mysql/ . En la misma instalación dará la opcion de ejecutar el asistente de configuración de instancia (‘Launch the MySQL Instance Configuration Wizard), marcar la casilla y seguir con la instalación. Para trabajar localmente habría que darle Siguiente en todos los pasos, hasta el apartado de Character set, donde habrá que elegir la utf8 (es el lenguaje universal y no habrá problemas con los caracteres). 2 pasos más en la instalación y aparecerá las opciones de seguridad, ahí habrá que crear una contraseña (en nuestro caso forman) y se habilitará la casilla ‘Enable root access from remote machines’.
Una vez instalado MySQL Server, hay que instalar MySQL Workbench 5.2. CE http://dev.mysql.com/downloads/workbench/5.2.html.

Con todo instalado, hay que ejecutar el Workbench. Se crea una base de datos con Add Schema y se crean las tablas dentro de él con add table. Cuando se crea una tabla te pide que Engine quieres usar, hay que tener en cuenta que el mejor para bases de datos complejas que permitan por ejemplo transacciones (Routines) o consultas anidadas, se debe usar InnoDB, en caso de ser menos compleja mejor usar MyISAM porque es mucho más rápida.

Uso de la librería MySQL JDBC.

Para hacer uso de base de datos en nuestro proyecto, hay que añadir la librería MySQL JDBC Driver, para ello pulsar con el segundo botón en la carpeta Libraries del proyecto y seleccionar Add Library.

A continuación se muestran distintos Snippets (trozos de código reutilizables) de las principales operaciones que se van a realizar en Java sobre una base de datos:

Seleccionar de una base de datos y mostrarla en una tabla
Connection conn=null;

Statement stm= null;

try {
  //crear el driver
  Class.forName("com.mysql.jdbc.Driver").newInstance();
  //obtener el manejador
  conn=DriverManager.getConnection("jdbc:mysql://localhost/agenda", "root", "forman");
  //obtener el statement
  stm= conn.createStatement();
  String sql="SELECT idcontactos,nombre,telefono,email FROM contactos WHERE idUsuario='"+idLogeado+"' ORDER BY nombre;";  //ejecutar la consulta
  ResultSet rst = stm.executeQuery(sql);
  int contador=0;
  While(rst.next()) {
      contador++;
      if(contador%2!=0){
      %>
         <tr style="background-color:lightcyan">
      <%
      }else{
      %>
      <tr>
      <%
      }
      %>
        <td width="70%"><!--Nombre-->
           <h4><%=rst.getString(2) %></h4>
        </td>
        <td width="10%"><!--Telefono-->
           <p><%=rst.getString(3) %></p>
        </td>
        <td width="10%">
           <a href="BorrarContactoServlet?id=<%=rst.getString(1)%>">Eliminar</a>
        </td>
        <td width="10%">
           <a href="modificar.jsp?id=<%=rst.getString(1)%>&nombre=<%=rst.getString(2)%>&telefono=<%=rst.getString(3)%>&email=<%=rst.getString(4)%>">Modificar</a>
        </td>
      </tr>
      <%
      if(contador%2!=0){
      %>
      <tr align="right" style="background-color:lightcyan">
      <%
      }else{
      %>
      <tr align="right">
      <%
      }
      %>
          <td><!--Email-->
            <h4><%=rst.getString(4) %></h4>
          </td>
       </tr>
       <%
       }
       if(contador==0){
       %>
       <tr>
          <td>
             <p>No hay ningún contacto</p>
          </td>
       </tr>
       <%
       }
       stm.close();
  }catch(SQLException err){
       System.out.println("Error SQLException: "+err.getMessage() +"\n"+err.toString());
  }catch(Exception e){
       System.out.println(e.getMessage());
 }finally{
       //cerrar la conexion
       if (conn!=null){
         try{
           conn.close();
         }catch(Exception e){}
       }
       out.close();
  }

En rojo se ha marcado el código específico para conectar y abrir la base de datos, y para realizar la consulta SQL. Tener en cuenta que cuando se hace una consulta con SELECT, es recomendable (por eficiencia) especificar siempre los campos que se quieren consultar, no poner un * para que te busque todos cuando algunos serán innecesarios. Despues se muestra en pantalla el resultado de la consulta, recorriéndola fila por fila e imprimiendo en una tabla.

Realizar acciones CRUD (Create – Read – Update – Delete)

// Crear
INSERT INTO Usuarios (Nombre, Apellidos, Correo) VALUES ('Juan Luis', 'Suárez', 'juanluis.suarez@gmail.com');
// Leer
SELECT nombre, apellidos, correo FROM Usuarios;
//Actualizar
UPDATE Usuarios SET nombre='Luisito' where Nombre='Juan Luis';
//Borrar
DELETE FROM Usuarios WHERE Nombre='Juan Luis';

Uso de LIKE y ORDER BY para las búsquedas.

String sql="SELECT idcontactos,nombre,telefono,email FROM contactos WHERE nombre LIKE '%"+request.getParameter("txtBuscar")+"%' ORDER BY nombre;";

Servlet y JSP – 2. Paso de parámetros

2012-02-01T10:28:00.000-08:00

Como se ha visto en la primera parte sobre Servlet y JSP, cuando el cliente (navegador) solicita una URL, esta se envía al servidor. En el servidor, se ejecutan archivos .jsp y .java. Cuando, por ejemplo, un index.jsp llamar a un servlet(.java) estos se comparten variables, de forma que el resultado de una variable en el servlet, se le pueda mandar al jsp, y viceversa.
En el ejemplo de la entrada anterior, solo usábamos el paso de parámetros de jsp a java, mediante el método POST de un formulario. Hay otros casos en las que necesitaremos pasarlas de otra forma, que son:

Envía de A.jsp a B.jsp (método GET)
- En A.jsp:
  <a href=”B.jsp?ID=1&NOMBRE=Fran”> Ir a B </a>
- En B.jsp:
  id=request.getParameter(“ID”);
  nombre=request.getParameter(“NOMBRE”);
Envía de A.jsp a Servlet.java:
- En A.jsp:
  <a href=”Servlet?ID=1″>Ir a Servlet</a>
  o
  request.setAttribute(“nombre_del_parametro”,valorDelParametro);
  request.getRequestDispatcher(“Servlet”).forward(request,response);
- En Servlet:
  id=request.getParameter(“ID”);
  o
  p=request.getAttribute(“nombre_del_parametro”);

Envía de Servlet.java a B.jsp:
- En Servlet.java:
  request.setAttribute(“nombre_del_parametro”,valorDelParametro);
  request.getRequestDispacher(“/B.jsp”).forward(request,response);
- En B.jsp:
  p=request.getAttribute(“nombre_del_parametro”);

Servlet y JSP – 1. Introducción

2012-01-30T09:39:00.000-08:00

Empiezo con el primer artículo Java. En primer lugar decir que los ejemplos que vaya poniendo en estos artículos los he comprobado y funcionan correctamente. Yo he usado Netbeans 7.0 como entorno de trabajo (lo recomienda Oracle), aunque podeis usar cualquier otro, como Eclipse. Así pues, empezamos con los servlets:

El funcionamiento del servlet se puede resumir en esta figura:

El servlet se utiliza para recibir peticiones, operar con esas peticiones y redireccionar a un JSP. Un JSP es código HTML con código Java incrustado que se compila en estos servlet.

Por ejemplo, esto es el código necesario para hacer un conversor de divisas, donde el cliente rellena un formulario y lo envía al servlet, el cual hará el cálculo y mostrará el resultado:

Código 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>
        <h1>Ejercicio 2.1</h1>
        <h2>Conversor de divisas</h2>
        <form method="POST" action="Ejercicio2Servlet">
            Dolares
            <input type="text" id="txtDolares" name="txtDolares"/>
            <br>
            <input type="submit" value="Convertir a Euros" />
            <br>
            Euros
            <input type="text" id="txtEuros" name="txtEuros"/>
            <br>
            <input type="submit" value="Convertir a Dolares" />
        </form>
    </body>
</html>


Código servlet

package org;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 *
 * @author Tarde
 */
@WebServlet(name = "Ejercicio2Servlet", urlPatterns = {"/Ejercicio2Servlet"})
public class Ejercicio2Servlet extends HttpServlet {

    /**
     * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();

        double dolares,euros;
        String dolaresQueEnvia, eurosQueEnvia, dolaresQueDevuelve,eurosQueDevuelve;

        try {
            out.println("<html>");
            out.println("<head>");
            out.println("</head>");
            out.println("<body>");

            dolaresQueEnvia=request.getParameter("txtDolares");
   eurosQueEnvia=request.getParameter("txtEuros");
            if(!dolaresQueEnvia.equals("")){
               dolares = Double.valueOf(dolaresQueEnvia).doubleValue();
               euros=dolares*0.71;
               eurosQueDevuelve=Double.toString(euros);
               out.println(dolaresQueEnvia + " dolares son " + eurosQueDevuelve + " euros.<br>");
            }
            if(!eurosQueEnvia.equals("")){
               euros = Double.valueOf(eurosQueEnvia).doubleValue();
               dolares=euros*1.73;
               dolaresQueDevuelve=Double.toString(dolares);
               out.println(eurosQueEnvia + " euros son " + dolaresQueDevuelve + " dolares.<br>");
            }
            out.println("</body>");
            out.println("</html>");

        } finally {
            out.close();
        }
    }

    // <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
    /**
     * Handles the HTTP <code>GET</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Handles the HTTP <code>POST</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Returns a short description of the servlet.
     * @return a String containing servlet description
     */
    @Override
    public String getServletInfo() {
        return "Short description";
    }// </editor-fold>
}
Lo que esta marcado en rojo indica la forma en que el servlet recibe los parámetros que le envió el JSP, es decir, los valores que el usuario introdujo en los campos de texto.

¡¡Bienvenidos!!

2012-01-30T04:36:00.000-08:00

Hola, bienvenido a mi blog donde podrás encontrar apuntes sobre JEE. Estos apuntes estan basados en lo aprendido en el curso Experto en desarrollo Java (J2EE) impartido por Forman. Además, tambien podrás encontrar otras ayudas para programar en otras tecnologías como Android...
Espero que te sirva de ayuda, saludos.

http://www.forman.es