Algo de fan art de un webcomic que leo – http://www.urbanjunglecomic.com/
Marketing
Archivos Mensuales: octubre 2013
Agregando enlaces a paginas Web a archivos Pdf con iText
EstándarAl momento de crear un archivo Pdf con iText puede darse el caso que necesite o desee agregar un enlace a una pagina web, por ejemplo la pagina web de su empresa, esto es perfectamente realizable desde iText y es bastante sencillo.
Preparando el proyecto.
Si ya a leído entradas previas de este blog ya sabrá como agregar la liberia iText a un proyecto en Eclipse, en caso de no conocer el procedimiento puede consultarlo a detalle en esta entrada: https://hashblogeando.wordpress.com/2013/07/14/itext-generacion-de-archivo-pdf-en-java/ en la que se detalla como configurar el proyecto y donde descargar la libreria iText, una vez que tenga generado el proyecto podemos proseguir.
Proyecto en Eclipse
Como puede ver en la figura 1, el proyecto de ejemplo consiste en una sola clase en el paquete mx.com.hashSoft.
Figura 1 – Proyecto en Eclipse
El código de la clase Hiperenlace se presenta a continuación, las partes importantes para generar el enlace aparecen resaltadas en rojo.
package mx.com.hashSoft;
import com.itextpdf.text.Anchor;
import com.itextpdf.text.BaseColor;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.pdf.PdfWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
/**
* Crea un documento Pdf con hiperenlaces a Internet, estos enlaces
* aparecen con letras azules y subrayados
*
* Referencias:
* http://tutorials.jenkov.com/java-itext/anchor.html
* http://geek-tutorials.com/java/itext/itext_bookmark_anchor.php
* @author david
*/
public class HiperEnlace {
static public void main(String[] args) {
Document documento = new Document();
Font fuente = new Font();
Paragraph parrafo = new Paragraph();
Anchor enlace = null;
// Creamos el documento
try{
PdfWriter.getInstance(documento, new FileOutputStream(“HyperEnlace.pdf”));
documento.open();
// Usaremos esta fuente para los enlaces
// Se establece el color azul
fuente.setColor( BaseColor.BLUE);
// Y el subrayado
fuente.setStyle(Font.UNDERLINE);
// Agregamos un parrefo
parrafo.add(new Phrase(
“Este es un ejemplo de como generar hiperenlaces, los cuales al darles click abren “
+ “una pagina en el navegador. Como puede observar dando click al siguiente\n”));
// Texto que se mostrara en el documento
enlace = new Anchor(“http://tutorials.jenkov.com/java-itext/anchor.html”, fuente);
// direccion URL a la que apunta el enlace
enlace.setReference(“http://tutorials.jenkov.com/java-itext/anchor.html”);
// Agregamos el enlace
parrafo.add(enlace);
// Agregamos otro parrafo
parrafo.add(new Phrase(“\nNotara que el pulsar el enlace abrio la pagina de una de las ” +
“Referencias de la entrada”));
documento.add(parrafo);
documento.close();
}catch(DocumentException e) {
System.err.println(“*********** Error al crear Documento”);
e.printStackTrace();
}catch(FileNotFoundException d) {
System.err.println(“*********** Error al abrir archivo”);
d.printStackTrace();
}
}
}
Font fuente = new Font(); Creamos un objecto Font, de modo que podamos crear una fuente personalizada, esto es necesario ya que por defecto los enlaces lucirán igual que el resto del texto, algo que seguramente no desea
Anchor enlace = null; Creamos un objecto que representa un enlace en el documento, por el momento no esta inicializado, pero eso cambiara en corto.
fuente.setColor( BaseColor.BLUE); Indicamos al nuestro objecto Font que deseamos el texto que use esta fuente sea del color indicado, en este caso Azul, indicado por la constante BaseColor.BLUE
fuente.setStyle(Font.UNDERLINE); Indicamos a nuestro objecto Font que el texto que use esta fuente debe de esta subrayado, esto junto a la instrucción anterior le dará a los enlaces el look clasico de texto azul subrayado
enlace = new Anchor(“http://tutorials.jenkov.com/java-itext/anchor.html”, fuente); Creamos el objecto Anchor el cual se presentara como un enlace en el documento, en esta versión en particular del constructor indicamos el texto que deseamos aparezca y la fuente con la que deseamos se escriba, aquí viene a la mano la fuente que definimos de modo que los enlaces resalten en el documento.
enlace.setReference(“http://tutorials.jenkov.com/java-itext/anchor.html”); La linea principal del enlace, con el método setReference indicamos a que URL nos debe dirigir el enlace al momento de pulsarlo
parrafo.add(enlace); Agrega el enlace al parrafo indicado.
Salida del programa
Una vez que ejecute el programa, en el directorio raiz del proyecto encontrara un archivo HyperEnlace.pdf que lucirá como la figura 2
Figura 2 – Salida
Y si pulsa el enlace lo llevara a una de las referencias que me ayudaron a crear esta entrada.
Figura 3 – Destino
Espero que esta entrada halla sido de utilidad y nos vemos en la próxima.
Acceder a una base de datos MySQL desde Java
EstándarLas bases de datos se han vuelto un elemento común en prácticamente todos los proyectos de software y existe una gran cantidad de formas de hacerlo, desde métodos que relacionan la salida de la consulta directamente a objetos a métodos muchos mas sencillos que usan directamente comandos de SQL, uno de estos últimos sera el tema de esta entrada.
Conector MySQL
Antes de comenzar necesitara tener un servidor MySQL y una base de datos a la que pueda acceder, por el momento no entrare en estos detalles y asumiré que ya los tiene, de no ser el caso basta con un comentario pidiendo mas detalles para crear una entrada del tema, a la vez necesitara de una libreria en Java para acceder a la base de datos el conector a MySQL, este puede ser descargado gratuitamente desde esta dirección: http://dev.mysql.com/downloads/connector/j/3.0.html una ves que tenga los elementos de base de datos y el conector podemos comenzar.
Figura 1 – Base de datos
Creando proyecto en Eclipse
Una vez que halla descargado el conector MySQL abralo y extraiga el archivo mysql-connector-java y agregelo a las librerias del proyecto, una forma de hacer esto esta descrita en una entrada anterior de este mismo blog: iText, Generación de archivo Pdf en Java, ahi encontrara el procedimiento para agregar una libreria a un proyecto en Eclipse, ya que halla agregado la libreria cree una clase Java en el paquete mx.com.hashDevel llamada AccesoDB el codigo de esta se presenta a continuación con las lineas relevantes resaltadas en rojo:
package mx.com.hashDevel;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class AccesoDB {
private Connection conexion = null;
private Statement comando = null;
private ResultSet resultados = null;
/**
* Inicia la conexion a la base de datos con un nombre de usuario y
* contraseña predefinidos
* @throws Exception
*/
public void iniciarConexion() throws Exception
{
String usuario=”inventario”;
String passwd = “1973”;
try{
Class.forName(“com.mysql.jdbc.Driver”);
conexion = DriverManager
.getConnection(“jdbc:mysql://127.0.0.1:3306/juegos”+ “?” + “user=”
+ usuario + “&” + “password=” + passwd + “”);
}catch(Exception e)
{
System.err.println(“Error al inciar la conexion a base de datos\t\t”);
e.printStackTrace();
throw e;
}
}
/**
* Consulta los datos en la tabla juegos, obtiene todos
* @throws SQLException
*/
public void consultarDatos() throws SQLException
{
String instruccion = “SELECT * FROM juegos.juegos”;
try {
comando = conexion.createStatement();
resultados = comando.executeQuery(instruccion);
} catch (SQLException e) {
e.printStackTrace();
throw e;
}
}
public void cerrarConexion() throws SQLException
{
try {
conexion.close();
} catch (SQLException e) {
e.printStackTrace();
throw e;
}
}
public void imprimirDatos() throws SQLException
{
int sistema;
int obtencion;
String nombre;
while(resultados.next())
{
try {
sistema = resultados.getInt(“consola”);
obtencion = resultados.getInt(“obtenido”);
nombre = resultados.getString(“nombre”);
} catch (SQLException e) {
e.printStackTrace();
throw e;
}
System.out.print(nombre + “\t\t\t”);
if(sistema == 1)
System.out.print(“Nintendo DS\t”);
else if(sistema == 2)
System.out.print(“Nintendo 3DS\t”);
else
System.out.print(“Xbox 360\t”);
if(obtencion == 1)
{
System.out.println(“Nuevo”);
}
else
{
System.out.println(“Segunda mano”);
}
}
}
}
Esta clase contiene las funciones necesarias para acceder a la base de datos, yendo desde inicial la conexión con la base de datos a leer e imprimir los datos en pantalla, las lineas resaltadas en rojo son las que acceden o inicializan las funciones en la base de datos, y se detallaran a continuación:
conexion = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/juegos”+ “?” + “user=” + usuario + “&” + “password=” + passwd + “”); Esta linea de codigo genera la conexión con la base de datos MySQL al parametro que se le pasa es el comando de conexión, una cadena de texto la cual debe de estar en el formato: jdbc:mysql://<Direccion del servidor>:<puerto>/<esquema>?user=<usuario>&password=<contraseña> en caso de error se genera una excepción.
comando = conexion.createStatement(); Generamos un objeto Statement a traves del cual podremos enviar consultas a la base de datos indicada por el objeto conexión
resultados = comando.executeQuery(instruccion); Ya que se tiene el objeto Statement podemos usar este para enviar consultas a la base de datos con esta instrucción, esta a su vez nos regresara los resultados de la consulta como un objeto ResultSet
conexion.close(); Cierra la conexión a la base de datos liberando los recursos en uso y la conexión
sistema = resultados.getInt(“consola”); Ya que tengamos los resultados de la consulta a la tabla podemos obtener el contenido del campo cuyo nombre es pasado como argumento en forma de un entero, los objectos ResultSet tiene metodos get para cada tipo de datos soportado or MySQL de modo que es la forma adecuada de obtener estos.
resultados.next() Avanza al siguiente registro de los resultados de la consulta regresando true si aun hay resultados y false cuando ya se esta al final de los registros
Ahora tambien cree la clase listado en el mismo paquete, esta simplemente llamara los metodos de AccesoDB
package mx.com.hashDevel;
public class listado {
static public void main(String[] args)
{
AccesoDB acceso = new AccesoDB();
try{
acceso.iniciarConexion();
acceso.consultarDatos();
acceso.imprimirDatos();
acceso.cerrarConexion();
}catch(Exception e)
{
System.err.println(“Error”);
}
}
}
Antes de ejecutar el programa recuerde modificarlo para la base de datos que tenga a la mano, o si lo prefiere recree la tabla juegos, los elementos de esta son:
- indice, tipo int, clave primaria
- consola, tipo int, valores usados 1, 2 y 3
- nombre, varchar(75)
- obtenido, int, valores validos 1 y 2
Hecho esto ejecute el programa, la salida debera ser similar a la Figura 3
Figura 3 – Salida del programa
Y si modifica los datos de la tabla, como se ve en la figura 4
Figura 4 – Modificaciones a los datos
Los resultados se modificaran de forma acorde cuando vuelva a correr el programa
Figura 5 – Nuevos resultados
Notara que los datos en efecto se actualizaron acorde a la base de datos.
Espero que esto halla sido útil y nos vemos en una próxima entrada
Feliz cumpleaños John Lennon
Vídeo
Y algo de musica que viene al caso
Enviado correos electronicos con JavaMail
EstándarUna de las funcionalidades deseables de algún sistema de manejo de datos seria el enviar automáticamente correos electrónicos al momento de que ocurra algún evento en particular, por fortuna si su sistema esta realizado en Java, agregar esta funcionalidad es bastante sencillo, gracias a la librería JavaMail.Para comenzar con su uso lo primero que necesitara es descargar dicha libreria desde la pagina http://www.oracle.com/technetwork/java/index-138643.html necesitara aceptar una licencia de terminos de uso para poder llevar a cabo la descarga, una vez que lo haga extraiga el archivo mail.jar del .zip que descargo
Figura 1 – mail.jar
Ahora necesita crear un nuevo proyecto en Eclipse y agregar dicha libreria (mail.jar) al proyecto, instrucciones detalladas en como realizar esta acción pueden encontrarse en una entrada anterior de este blog, basta con que remplaze itext.jar con mail.jar https://hashblogeando.wordpress.com/2013/07/14/itext-generacion-de-archivo-pdf-en-java/ el proyecto resultante lucira similar a la figura 2
Figura 2 – Proyecto con mail.jar
Notara que en la figura el proyecto contiene dos archivos en el paquete mx.com.develHash.correo, los cuales son el código de nuestro programa y el archivo de propiedades, este ultimo es un archivo de texto plano con este contenido:
mail.smtp.host=smtp.gmail.com
mail.smtp.socketFactory.port=465
mail.smtp.starttls.enable=true
mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory
mail.smtp.port=465
mail.smtp.auth=true
Copie estos datos en un archivo gmail.properties y coloque dicho archivo en el mismo directorio donde esta el código de nuestro programa como muestra la figura 3
Figura 3 – Ubicación de archivo .properties
La ubicación del archivo es muy importante, ya que el archivo gmail.properties contiene los datos para conectarse con el servidor de gmail y enviar un correo usando SSL
Ahora si, cree una nueva clase Java con el nombre CorreoSender.Java y copie el siguiente código:
package mx.com.develHash.correo;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
/**
* Crea y envia un correo electronico
* @author david
*
*/
public class CorreoSender {
static public void main(String[] args) {
// Nombre de usuario y contraseña del correo respectivamente
final String usuario = “<Su correo en gMail>”;
final String passwd = “<Su contraseña>”;
Properties props = new Properties();
DateFormat dateFormat = new SimpleDateFormat(“yyyy/MM/dd HH:mm:ss”);
Calendar cal = Calendar.getInstance();
Session session;
// Obtenemos los datos para utilizar el servidor de correo
try {
props.load(CorreoSender.class.getClassLoader().getResourceAsStream(
“mx/com/develHash/correo/gmail.properties”));
} catch (IOException e) {
System.err.println(“********** Error al acceder a gmail.properties”);
e.printStackTrace();
}
// Iniciamos sesion para envio de correos
session = Session.getInstance(props, new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(usuario, passwd);
}
});
// Creamos el coreo
try {
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(usuario));
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(“<Destinatario>“));
message.setSubject(“Correo de prueba”);
message.setText(“Mensaje de prueba generado en la fecha “
+ dateFormat.format(cal.getTime() ) );
// Enviamos el correo
System.out.println(“Enviando correo…”);
Transport.send(message);
System.out.println(“Correo enviado”);
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}
Las lineas en rojo se detallaran a continuación:
final String usuario = “<Su correo en gMail>” y final String passwd = “<Su contraseña>”: Estas dos cadenas de texto simplemente contienen el nombre de usuario y la contraseña de su correo, en este caso particular el usuario y contraseña de su cuenta en gmail, cabe mencionar que el usuario debe estar en la forma nombreUsuario@gmail.com o de lo contrario no funcionara.
props.load(CorreoSender.class.getClassLoader().getResourceAsStream( “mx/com/develHash/correo/gmail.properties”));
Con esta linea cargamos el contenido del archivo gmail.properties, que ,como ya se menciono, contiene los parametros de conexión con el servidor de gmail, noatara que en la linea indicada se hace mencion tanto al nombre de la clase, CorreoSender, como a la ruta interna del paquete, mx/com/develHash/correo/gmail.properties, esto es vital para que nuestro programa funcione, por lo que si modifico alguno de esos datos el cambio debe de reflejarse aquí también.
session = Session.getInstance(props, new javax.mail.Authenticator() { protected PasswordAuthentication getPasswordAuthentication() { return new PasswordAuthentication(usuario, passwd); } Iniciamos una sesión con el servidor de correo y nos identificamos con este por medio del usuario y contraseña que declaramos anteriormente.
message.setFrom(new InternetAddress(usuario)); Indicamos quien es el remitente del correo
message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(<Destinatario>)); Indicamos a quien deseamos enviar el correo.
message.setSubject(“Correo de prueba”); Establecemos cual es el asunto del mensaje.
message.setText(“Mensaje de prueba generado en la fecha “ + dateFormat.format(cal.getTime() ) ); indicamos el texto del mensaje, en este caso en particular se agrega la fecha y hora de envio.
Transport.send(message); Enviamos el mensaje.
Una vez que ejecute el programa, si todo salio bien, obtendrá una salida en consola similar a la figura 4, debo mencionar que el envio no es instantáneo de que aparezca el mensaje “Enviando Correo…” a que se muestre “Correo Enviado” tomara un par de segundos.
Figura 4 – Salida del programa
Puede comprobar que el correo se halla enviado adecuadamente con abrir la cuenta de destino que halla seleccionado, lo que debería mostrarle un mensaje similar a la figura 5
Figura 5 – Resultado
Ya para concluir debo recordar que el ejemplo usa el correo con SSL, si bien esto es una medida de seguridad extra que no esta demas podría darse el caso que desee evitarla, si asi fuera le recomiendo revisar los ejemplos indicados en el area de referencias, los cuales además podrian darle ideas que tal vez se ajusten mas a lo que desea obtener. Aparte las posibilidades con javamail son bastante extensas y espero cubrir mas de estas en el futuro.
Por lo pronto espero que la entrada halla sido de ayuda y nos vemos pronto.
Referencias
http://www.chuidiang.com/java/herramientas/javamail/empezar-javamail.php
http://www.mkyong.com/java/javamail-api-sending-email-via-gmail-smtp-example/
Accediendo a archivos de propiedades en Java
EstándarAl momento de crear aplicaciones en Java puede necesitar almacenar parámetros que la aplicación necesitara, que puede ir desde direcciones de correo, direcciones para acceso a base de datos, información de conexión o datos varios, si bien hay varias formas de hacer esto, yendo desde bases de datos a crear uno mismo los archivos, Java nos proporciona un mecanismo integrado para realizar esto, los archivos de propiedades.
Estos son sencillamente archivos de texto con el formato
<nombre_clave>=<valor_clave>
Los cuales Java tiene mecanismos para acceder en forma nativa y que nos presenta una convención en donde deben ubicarse dichos archivos, de modo que mover la aplicación en el sistema de archivos o llevarla a otro sistema no cause problemas, esto se explicara con mas detalle a su momento.
Creando el proyecto.
Comenzaremos creando un proyecto en Java, como se ve en la figura 1, si a leído entradas anteriores ya habrá notado que siempre uso el paquete mx.com.hashSoft, esta vez no sera la excepción, pero ahora es parte vital del programa por lo que debe recordar agregarlo al momento de crear la clase Propiedades.
Figura 1 – Proyecto nuevo
Figura 2 – Archivo de texto
Ahora crearemos el archivo propiedades, para esto cree un archivo de texto, como se ve en la figura 2, ya que el archivo exista escriba en este lo siguiente:
version=1.0
tipo=texto
data=”Datos Datos Datos Datos Datos”
Y guarde el archivo, esto le presentara un dialogo como el de la figura 3
Figura 3 – Ruta del archivo
En este caso es vital que siga la ruta indicada, esto es necesario, la idea general es que nuestro archivo properties este en la misma carpeta donde nuestra clase esta, esto es necesario para poder acceder a este.
Figura 4 – Codigo de la clase Propiedades
Ahora procederemos a escribir el código de la clase Propiedades, el cual es el siguiente:
package mx.com.hashSoft;
import java.io.IOException;
import java.util.Properties;
public class Propiedades {
static public void main(String[] args){
Properties prop = new Properties();
try {
prop.load( Propiedades.class.getClassLoader().getResourceAsStream(“mx/com/hashSoft/datos.properties”) );
System.out.println(“Contenido del campo version:\t” + prop.getProperty(“version”) );
System.out.println(“Contenido del campo tipo:\t” + prop.getProperty(“tipo”) );
System.out.println(“Contenido del campo data:\t” + prop.getProperty(“data”) );
}catch(IOException ex)
{
System.err.println(“Error al acceder al archivo de propiedades”);
ex.printStackTrace();
}
}
}
De esta clase hay tres lineas relevantes, que son:
import java.util.Properties; – Con esta linea importamos la clase necesaria para manipular y acceder a los archivos de propiedades
prop.load( Propiedades.class.getClassLoader().getResourceAsStream(“mx/com/hashSoft/datos.properties”) ); – Con esta linea estamos indicando que archivo de propiedades deseamos cargar, en este caso deseamos cargar datos.properties, que se encuentra en la ruta mx/com/hashSoft, notara que si remplaza los / con . obtiene el paquete Java donde ubicamos el archivo properties, como en la figura 5 Eclipse genero esa ruta automáticamente de modo que la estructura de los paquetes Java coincida con al organización de los archivos
Figura 5 – Ruta del archivo properties
Todo esto podrá parecer demasiado rebuscado, mas por que es, en efecto, posible escribir directamente la ruta del archivo, sin embargo hay una razón para acceder a los archivos de este modo en la mayoría de los casos no puede saber a ciencia cierta detalles como la ruta de instalación o el directorio donde se esta ejecutando el programa no se diga cuando se trata de una aplicación que se ejecuta en un servidor, pero el classpath siempre esta perfectamente definido y se mantiene constante, lo que hace este el modo mas seguro para acceder a los archivos properties.
Ya que tenga ambos archivos puede ejecutar el programa , con lo que obtendrá una salida como la figura 6
Figura 6 – Salida
Puede modificar el archivo properties y con eso modificar la salida del programa, como ejemplo digamos que escribiera “tipo” con mayúscula, si hace ese cambio y ejecuta el programa obtendrá la salida de la figura 7, lo que demuestra que las claves distinguen de mayúsculas y minúsculas.
Figura 7 – Archivo Modificado
Y si cambia el valor de la clave eso se refleja en la salida, como muestra la figura 8
Figura 8 – Cambio de valor
Y notara que incluso puede cambiar el orden en que están las claves y aun así la salida es la esperada.
Espero que la entrada halla sido de ayuda, y nos vemos pronto.
Referencias
Java Properties File Examples – http://www.mkyong.com/java/java-properties-file-examples/
