Cómo guardar documentos de doc, pdf y de imagen en la base de datos mysql usando java?

Question

Estoy tratando de guardar .doc, .pdf, .txt, y archivos de imagen en mi base de datos utilizando hibernate, jsf y mysql.

He creado una columna para guardar el archivo de tipo BLOB. Si guardo el tipo .txt, los archivos se guardan correctamente.

Si intento guardar un archivo de cualquier otro formato, recibo una excepción. En mi bean he creado un nombre de campo: byte[] file;

¿Cómo puedo guardarlo correctamente sin ninguna excepción? ¿Debo cambiar el tipo de datos para la columna mysql o usar un campo diferente para la clase Java?

---

(en respuesta a BalusC)

Este es el código que estoy utilizando para escribir archivos. Estoy usando fileInputStream y luego guardo el archivo usando hibernate framework.

Iterator iter = items.iterator(); 
while (iter.hasNext()) { 
FileItem item = (FileItem) iter.next(); 

if (item.isFormField()) { 
    String name = item.getFieldName(); 
    String value = item.getString(); 
} else { 
    String fieldName = item.getFieldName(); 
    String fileName = item.getName(); 
    String contentType = item.getContentType(); 
    boolean isInMemory = item.isInMemory(); 
    long sizeInBytes = item.getSize(); 
    byte[] fileInBytes=item.get(); 


    try { 
     File uploadedFile = new File("/home/db/webApp", fileName); 
     uploadedFile.createNewFile(); 
     FileInputStream fileInputStream = new FileInputStream(uploadedFile); 
     //convert file into array of bytes 
     fileInputStream.read(fileInBytes); 
     fileInputStream.close(); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 

    UploadedFile object= new UploadedFile(); 
    object.setFile(fileInBytes); 
    uploadedObject.setFileName(fileName); 
    session.save(object); 

UploadedFile es JSF bean administrado:

public class UploadedFile{ 
    private String fileName; 
    private byte[] file; 
    /** 
    * @return the fileName 
    */ 
    public String getFileName() { 
     return fileName; 
    } 
    /** 
    * @param fileName the fileName to set 
    */ 
    public void setFileName(String fileName) { 
     this.fileName = fileName; 
    } 
    /** 
    * @return the file 
    */ 
    public byte[] getFile() { 
    return file; 
    } 
    /** 
    * @param file the file to set 
    */ 
    public void setFile(byte[] file) { 
     this.file = file; 
    } 
} 

y mi tabla de base de datos se estructura siguiente:

Create UploadFile(FILE_NAME` VARCHAR(1000) NOT NULL, 
`FILE` BLOB NOT NULL); 

Answer 1

es mejor para guardar el archivo en una ubicación y guardar la posición en la base de datos

Answer 2

Almacenar el archivo meta i nfo como la ubicación en db, pero sincronizar db y el sistema de archivos será un problema.

Answer 3

Parece que su problema es un tipo de datos. Un BLOB en MySQL no es muy grande. Intente configurar el tipo de datos de columna de su tabla a un LONGBLOB en su lugar.

Answer 4

package com.server; 


import java.io.*; 

import java.sql.*; 
import java.util.*; 
import java.text.*; 
import java.util.regex.*; 
import org.apache.commons.fileupload.servlet.ServletFileUpload; 
import org.apache.commons.fileupload.disk.DiskFileItemFactory; 
import org.apache.commons.fileupload.*; 
import org.mortbay.jetty.Response; 

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

import java.io.*; 
import java.sql.*; 
import javax.servlet.http.HttpServlet; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 
import javax.servlet.ServletInputStream.*; 
import java.io.PrintWriter; 

public class XmlServlet extends HttpServlet { 

public void doPost(HttpServletRequest req,HttpServletResponse res) 
{ 
    File uploadedFile; 


    System.out.print("on server"); 
try{ 

Class.forName("com.mysql.jdbc.Driver"); 
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3308/image","root","root1"); 

PrintWriter out=res.getWriter(); 

//out.println("<br>Content type is :: " +contentType); 
//to get the content type information from JSP Request Header 
String contentType = req.getContentType(); 
int flag=0; 
FileInputStream fis=null; 
FileOutputStream fileOut=null; 
//here we are checking the content type is not equal to Null and as well as the passed data from mulitpart/form-data is greater than or equal to 0 
if ((contentType != null) && (contentType.indexOf("multipart/form-data") >= 0)) 
{ 
DataInputStream in = new DataInputStream(req.getInputStream()); 
//we are taking the length of Content type data 
int formDataLength = req.getContentLength(); 
byte dataBytes[] = new byte[formDataLength]; 
int byteRead = 0; 
int totalBytesRead = 0; 

//this loop converting the uploaded file into byte code 
while (totalBytesRead < formDataLength) { 
byteRead = in.read(dataBytes, totalBytesRead,formDataLength); 
totalBytesRead += byteRead; 
} 

String file = new String(dataBytes); 
//for saving the file name 
String saveFile = file.substring(file.indexOf("filename=\"") + 10); 
saveFile = saveFile.substring(0, saveFile.indexOf("\n")); 
out.println("savefiledddd"+saveFile); 
int extension_save=saveFile.lastIndexOf("\""); 
String extension_saveName=saveFile.substring(extension_save); 

//Here we are invoking the absolute path out of the encrypted data 

saveFile = saveFile.substring(saveFile.lastIndexOf("\\")+ 1,saveFile.indexOf("\"")); 
int lastIndex = contentType.lastIndexOf("="); 
String boundary = contentType.substring(lastIndex + 1,contentType.length()); 
int pos; 

//extracting the index of file 
pos = file.indexOf("filename=\""); 
pos = file.indexOf("\n", pos) + 1; 
pos = file.indexOf("\n", pos) + 1; 
pos = file.indexOf("\n", pos) + 1; 
int boundaryLocation = file.indexOf(boundary, pos) - 4; 
int startPos = ((file.substring(0, pos)).getBytes()).length; 
int endPos = ((file.substring(0, boundaryLocation)).getBytes()).length; 

out.println("savefile"+saveFile); 

int file_No=22; 

uploadedFile=new File("./war/img"); 

    uploadedFile.mkdir(); 


    String kk=uploadedFile.getAbsolutePath(); 


    String pathname_dir=kk+"/"+saveFile; 
    //String pathname_dir="C:\\Program Files\\Apache Software Foundation\\Tomcat 6.0\\jk\\"+saveFile; 
    File filepath=new File(pathname_dir); 
    out.println("filepath_ "+filepath); 
    fileOut = new FileOutputStream(filepath); 
    fileOut.write(dataBytes, startPos, (endPos - startPos)); 
    fileOut.flush(); 
    out.println("<h1> your files are saved</h1></body></html>"); 
    out.close(); 

     File database_filename=new File(pathname_dir); 
      fis=new FileInputStream(database_filename); 

int len=(int)database_filename.length(); 
      PreparedStatement ps = conn.prepareStatement("insert into new (image) values (?)"); 
      ps.setBinaryStream(1,fis,len); 
      ps.executeUpdate(); 
      ps.close(); 
      flag=1; 

} 

if(flag==1) 
{ 
fileOut.close(); 
fis.close(); 
} 
}catch(Exception e) 
{ 
System.out.println("Exception Due to"+e); 
e.printStackTrace(); 
} 
} 
} 

Es un código de servidor. Con ese código, puede cargar cualquier archivo que esté almacenado en la base de datos y almacenar ese archivo en el lado del servidor en la carpeta (img). Al usar la referencia de eso, puede acceder al archivo.