Una de las revistas interesantes que teratan temas sobre desarrollo, miscelanias, etc en Ubuntu.
Este mes:
Navegando por internet encontre este interesante informe de un canal argentino donde se muestra como es que viven la gente de google.
Primer informe:
En ocasiones queremos saber como insertar un tipo de dato Date del paquete java.sql, normalmente para hacerlo realizamos una conversión CASTING en la sentencia SQL que se le manda a la base de datos, p.e
INSERT INTO ... VALUES(..., convert(varchar,DateColumn,103)...)
En el caso de que no deseamos realizar esa conversion, tenemos el siguiente código:USE pubs
GO
CREATE TABLE test(test_varchar VARCHAR(255), test_date DATETIME)
GO
Enlaces de interes:/*
* Main.java
*/
package testinsertdate;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
*
* @author hugo
*/
public class Main {
/** Creates a new instance of Main */
public Main() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws ParseException {
int result = 0;
Connection con = null;
PreparedStatement ps = null;
SimpleDateFormat fecha = new SimpleDateFormat( "dd/MM/yyyy" );
try{
ConnectionFactory cf = new ConnectionFactory( ConnectionFactory.TYPE_MSSQL,
"localhost", "pubs" );
con = cf.getConnection( "sa", "sa" );
ps = con.prepareStatement( "INSERT INTO test VALUES( ?, ? )" );
ps.setString( 1, "test2" );
ps.setDate( 2, new Date( fecha.parse( "15/02/1982" ).getTime() ) );
ps.executeUpdate();
System.out.println( "Conversion sin excepcion!" );
}catch( SQLException sqle ){
sqle.printStackTrace();
}catch( ParseException pe){
pe.printStackTrace();
}finally{
if( ps != null ) ConnectionFactory.close(ps);
if( con != null ) ConnectionFactory.close(con);
}
}
}
Esta es una de las primeros videos tutoriales que iré introduciendo en este blog sobre php y otras tecnologías :)
Descargar ficheros es sumamente sencillo desde el servidor, el problema surge cuando queremos subirlos, los JSP y Servlets de Java no tienen mecanismos para poder manejar la subida de ficheros desde formularios, siendo un problema tratar de extraer el contenido desde HTTP request. Una mejor opcion que nos puede ayudar es utilizar librerias de terceros.
Existe una robusta libreria open-source diseñada para este propósito del paquete Apache Jakarta Commons FileUpload.
Requerimientos
<form method="POST" enctype="multipart/form-data"
action="<%= request.getContextPath()%>/UploadFile">
Por favor, seleccione el trayecto del fichero a cargar
<br><input type="file" name="fichero">
<input type="submit">
</form>
Figura 1: formulario JSP para subir un archivo al servidorpackage servlets;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.File;
import java.util.List;
import java.util.Iterator;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
/**
*
* @author hugo
* @version
*/
public class UploadFile extends HttpServlet {
private String dirUploadFiles; //directorio donde se guardara los archivos
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
// 1. obtengo el directorio donde guardare los archivos, desde un parametro de
// contexto en el archivo web.xml
dirUploadFiles = getServletContext().getRealPath( getServletContext().getInitParameter( "dirUploadFiles" ) );
// 2. Si la peticion es de tipo multi-part,
// static boolean isMultipartContent() devuelve true/false
if( ServletFileUpload.isMultipartContent( request ) ){
// 3. crear el arhivo factory
// DiskFileItemfactory es una implementacion de FileItemfactory
// esta implementacion crea una instacia de FileItem que guarda su
// contenido ya sea en la memoria, para elementos pequeños,
// o en un archivo temporal en el disco, para los
// elementos de mayor tamaño
FileItemFactory factory = new DiskFileItemFactory();
// 4. crear el servlet upload
// es un API de alto nivel para procesar subida de archivos
// Por defecto la instancia de ServletFileUpload tiene los siguientes valores:
// * Size threshold = 10,240 bytes. Si el tamaño del archivo está por debajo del umbral,
// se almacenará en memoria. En otro caso se almacenara en un archivo temporal en disco.
// * Tamaño Maximo del cuerpo de la request HTTP = -1.
// El servidor aceptará cuerpos de request de cualquier tamaño.
// * Repository = Directorio que el sistema usa para archivos temporales.
// Se puede recuperar llamando a System.getProperty("java.io.tmpdir").
ServletFileUpload upload = new ServletFileUpload( factory );
/* 5. declaro listUploadFiles
* Contendrá una lista de items de archivo que son instancias de FileItem
* Un item de archivo puede contener un archivo para upload o un
* campo del formulario con la estructura simple nombre-valor
* (ejemplo: <input name="text_field" type="text" />)
*
* Podemos cambiar las opciones mediante setSizeThreshold() y setRespository()
de la clase DiskFileItemFactory y el
método setSizeMax() de la clase ServletFileUpload, por ejemplo:
DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory();
diskFileItemFactory.setSizeThreshold(40960); // bytes
File repositoryPath = new File("/temp");
diskFileItemFactory.setRepository(repositoryPath);
ServletFileUpload servletFileUpload = new ServletFileUpload(diskFileItemFactory);
servletFileUpload.setSizeMax(81920); // bytes
*
*/
// limito a 300 Kb el humbral del tamaño del archivo a subir
// Long.parseLong( getServletContext().getInitParameter( "maxFileSize" ) )
upload.setSizeMax( new Long( getServletContext().getInitParameter( "maxFileSize" ) ).longValue() ); // 1024 x 300 = 307200 bytes = 300 Kb
List listUploadFiles = null;
FileItem item = null;
try{
// 6. adquiere la lista de FileItem asociados a la peticion
listUploadFiles = upload.parseRequest( request );
/* 7. Iterar para obtener todos los FileItem
* vamos a trabajar con generalidad
* programaremos como si quisieramos leer todos los
* campos sean 'simples' o 'file'. Por ello iteramos
* sobre todos los FileItem que recibimos:
* Los parámetros simples los diferenciaremos de los parámetros 'file'
* por medio del método isFormField()
*/
Iterator it = listUploadFiles.iterator();
while( it.hasNext() ){
item = ( FileItem ) it.next();
// 8. evaluamos si el campo es de tipo file, para subir al servidor
if( !item.isFormField() ){
//9. verificamos si el archivo es > 0
if( item.getSize() > 0 ){
// 10. obtener el nombre del archivo
String nombre = item.getName();
// 11. obtener el tipo de archivo
// e. .jpg = "image/jpeg", .txt = "text/plain"
String tipo = item.getContentType();
// 12. obtener el tamaño del archivo
long tamanio = item.getSize();
// 13. obtener la extension
String extension = nombre.substring( nombre.lastIndexOf( "." ) );
out.println( "Nombre: " + nombre + "<br>");
out.println( "Tipo: " + tipo + "<br>");
out.println( "Extension: " + extension + "<br>");
// 14. determinar si el caracter slash es de linux, o windows
//String slashType = ( nombre.lastIndexOf( "\\" ) > 0 ) ? "\\" : "/"; // Windows o Linux
// 15. obtener la ultima posicion del slash en el nombre del archivo
//int startIndex = nombre.lastIndexOf( slashType );
// 16. obtener el nombre del archivo ignorando la ruta completa
//String myArchivo = nombre.substring( startIndex + 1, nombre.length() );
// 17. Guardo archivo del cliente en servidor, con un nombre 'fijo' y la
// extensión que me manda el cliente,
// Create new File object
File archivo = new File( dirUploadFiles, nombre );
// 18. Write the uploaded file to the system
item.write( archivo );
if ( archivo.exists() ){
out.println( "GUARDADO " + archivo.getAbsolutePath() + "</p>");
}else{
// nunca se llega a ejecutar
out.println( "FALLO AL GUARDAR. NO EXISTE " + archivo.getAbsolutePath() + "</p>");
}
}
}
}
}catch( FileUploadException e ){
e.printStackTrace();
}catch (Exception e){
// poner respuesta = false; si existe alguna problema
e.printStackTrace();
}
}
out.println( "Fin de la operacion! ;)");
out.close();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
}<servlet>
<servlet-name>UploadFile</servlet-name>
<servlet-class>servlets.UploadFile</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>UploadFile</servlet-name>
<url-pattern>/UploadFile</url-pattern>
</servlet-mapping>
<context-param>
<param-name>dirUploadFiles</param-name>
<param-value>/public/images/avatar</param-value>
</context-param>
<context-param>
<param-name>maxFileSize</param-name>
<param-value>307200</param-value>
</context-param>
Figura 2: Procesamiento de la subida de un fichero al servidor
Download source codeEn esta segunda entrega veremos en primer lugar la implementación de una clase que nos permitirá manejar las operaciones de conexiíon con SQL Server 2005 ( y con otras más):
package sqlserver2005;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.CallableStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class ConnectionFactory {
public final static int TYPE_MSSQL = 10;
public final static int TYPE_MYSQL = 20;
public final static int TYPE_ORACLE_10G_EX = 30;
public final static int TYPE_MSSQL2005 = 40;
private String driver;
private String url;
/**
* Constructor que carga el driver jdbc para poder trabajar con la base de datos
*
* @param typeDBMS tipo de base de datos a utilizar
* @param hostName IP o nombre del servidor de base de datos
* @param databaseName nombre de la base de datos con la que deseamos trabajar
*/
public ConnectionFactory( int typeDBMS, String hostName, String databaseName ) {
switch( typeDBMS ){
case 10:{ // Para SQL Server 2000
driver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
url = "jdbc:microsoft:sqlserver://" + hostName + ":1433;DatabaseName=" +
databaseName;
break;
}
case 20:{ // Para MySQL 5.0
driver = "com.mysql.jdbc.Driver";
url = "jdbc:mysql://" + hostName + ":3306/" +
databaseName;
break;
}
case 30:{ // Para en Oracle 10g Express Edition
if( databaseName.equals( "" ) )
databaseName = "XE";
else
databaseName = "XE";
driver = "oracle.jdbc.driver.OracleDriver";
url = "jdbc:oracle:thin:@//" + hostName + ":1521/" + databaseName;
break;
}
case 40:{ // Para SQL Server 2005 Express Edition
driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
url = "jdbc:sqlserver://" + hostName + ":1433;DatabaseName=" +
databaseName;
break;
}
}
try{
// cargar la clase Driver
Class.forName( driver );
}catch( ClassNotFoundException cnfe ){
System.out.println( "Error: exception loading driver class" );
}
}
/**
* Devuelve un objeto de tipo Connection válido
*
* @param user usuario de la base de datos
* @param password clave del usuario de la base de datos
* @return Connection
*/
public Connection getConnection( String user, String password ) throws SQLException
{
return DriverManager.getConnection( url, user, password );
}// fin del metodo getConnection
/**
* Metodo para liberar recursos de memoria, cerrando la conextion con la base
* de datos
*
* @param con parametro de tipo Connection
*/
public static void close( Connection con ){
try{
con.close();
}catch( SQLException sqle ){
showMessageError( sqle );
}
}// fin del método closeConnection
/**
* Cierra un objeto ResultSet (Registros)
* @param con parametro de tipo ResultSet
*/
public static void close( ResultSet rs ){
try{
rs.close();
}catch( SQLException sqle ){
showMessageError( sqle );
}
}// fin del método closeConnection
/**
* Cierra un objeto Statement (Consulta)
* @param con parametro de tipo Statement
*/
public static void close( Statement stmt ){
try{
stmt.close();
}catch( SQLException sqle ){
showMessageError( sqle );
}
}// fin del método close
/**
* Cierra un objeto Statement (Consulta)
* @param con parametro de tipo Statement
*/
public static void close( PreparedStatement ps ){
try{
ps.close();
}catch( SQLException sqle ){
showMessageError( sqle );
}
}// fin del método close
/**
* Cierra un objeto Statement (Consulta)
* @param con parametro de tipo Statement
*/
public static void close( CallableStatement cs ){
try{
cs.close();
}catch( SQLException sqle ){
showMessageError( sqle );
}
}// fin del método close
/** muestra un mensaje de error en consolo, según sea el caso */
private static void showMessageError( SQLException sqle ){
System.out.println( "Error:" +
"\nmensaje: " + sqle.getMessage() +
"\nSQLState: " + sqle.getSQLState() +
"\nVencorCode: " + sqle.getErrorCode() + "\n" );
}// fin del método showMessageError
}
Introduccion
En este tutorial veremos como conectarnos y mostrar datos de SQL Server 2005 Express con JDBC.
Todo esta dividido en 4 partes:
Network error IOException: Connection refused: connec
2. En el objeto Explorador, click derecho en el nombre de instancia y seleccionar propiedades.
4. Click derecho otravés en el nombre de la instancia, seleccionar Restart para reiniciar el Servicio de SQL Server.
5. Esto es todo. Tienes habilitado el modoSQL Server and Windows authenticat ion, ahora usted puede iniciar sesion en SQL Server con su cuenta de Windows o su cuenta creada.
10. Click derecho otravés en el nombre de la instancia, seleccionar Restart para reiniciar el Servicio de SQL Server.
Probando lo hecho:
