Serializzare e lavorare con un documento in un database

Una delle attività che potrebbe essere necessario eseguire quando si lavora con i documenti è la memorizzazione e il recupero di oggetti Document da e verso un database. Ad esempio, ciò sarebbe necessario se si implementasse qualsiasi tipo di sistema di gestione dei contenuti. Tutte le versioni precedenti dei documenti devono essere memorizzate nel sistema di database. La possibilità di archiviare documenti nel database è anche estremamente utile quando l’applicazione fornisce un servizio basato sul Web.

Aspose.Words fornisce la possibilità di convertire un documento in un array di byte per il lavoro successivo con questo documento in un database.

Convertire un documento in array di byte

Per memorizzare un documento in un database o per preparare un documento per la trasmissione attraverso il Web, è spesso necessario serializzare il documento per ottenere un array di byte.

Per serializzare un oggetto Document in Aspose.Words:

1. Salvalo su un MemoryStream usando il metodo Save overload della classe Document.
2. Chiamare il metodo ToArray, che restituisce un array di byte che rappresentano il documento in forma di byte.

I passaggi precedenti possono quindi essere invertiti per caricare nuovamente i byte in un oggetto Document.

Il formato di salvataggio selezionato è importante per garantire la massima fedeltà durante il salvataggio e il ricaricamento nell’oggetto Document. Per questo motivo, si consiglia di utilizzare una serie di formati di file OOXML.

L’esempio seguente mostra come serializzare un oggetto Document per ottenere un array di byte e quindi come deserializzare l’array di byte per ottenere di nuovo un oggetto Document:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// Load the document.
Document doc = new Document(dataDir + "Test File (doc).doc");

// Create a new memory stream.
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
// Save the document to stream.
doc.save(outStream, SaveFormat.DOCX);

// Convert the document to byte form.
byte[] docBytes = outStream.toByteArray();

// The bytes are now ready to be stored/transmitted.

// Now reverse the steps to load the bytes back into a document object.
ByteArrayInputStream inStream = new ByteArrayInputStream(docBytes);

// Load the stream into a new document object.
Document loadDoc = new Document(inStream);

È possibile scaricare il file modello di questo esempio da Aspose.Words GitHub.

Memorizzare, leggere ed eliminare un documento in un database

Questa sezione mostra come salvare un documento in un database e quindi caricarlo nuovamente in un oggetto Document per lavorare con esso. Per semplicità, il nome del file è la chiave utilizzata per archiviare e recuperare i documenti dal database. Il database contiene due colonne. La prima colonna “FileName " viene memorizzata come una Stringa e viene utilizzata per identificare i documenti. La seconda colonna “FileContent " viene memorizzata come oggetto BLOB che memorizza l’oggetto documento nel modulo byte.

Il seguente esempio di codice mostra come impostare una connessione a un database ed eseguire comandi:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
String url1 = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "123";

// Open a database connection.
Connection mConnection = DriverManager.getConnection(url1, user, password);

In questo esempio, usiamo il database MySQL per memorizzare un documento Aspose.Words.

L’esempio di codice seguente mostra come salvare un documento nel database, quindi leggere nuovamente lo stesso documento e infine eliminare il record contenente il documento dal database:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// Store the document to the database.
StoreToDatabase(doc, mConnection);

// Read the document from the database and store the file to disk.
Document dbDoc = ReadFromDatabase(dataDir + fileName, mConnection);

// Save the retrieved document to disk.
dbDoc.save(dataDir + fileName);

// Delete the document from the database.
DeleteFromDatabase(dataDir + fileName, mConnection);

// Close the connection to the database.
mConnection.close();

Salvare un documento in un database

Per salvare un documento in un database convertire questo documento in una matrice di byte, come descritto all’inizio di questo articolo. Quindi, salvare questo array di byte in un campo di database.

L’esempio di codice seguente mostra come salvare un documento nel database specificato:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
public static void StoreToDatabase(Document doc, Connection mConnection) throws Exception {
	// Create an output stream which uses byte array to save data
	ByteArrayOutputStream aout = new ByteArrayOutputStream();
	// Save the document to byte array
	doc.save(aout, SaveFormat.DOCX);
	// Get the byte array from output steam
	// the byte array now contains the document
	byte[] buffer = aout.toByteArray();

	// Get the filename from the document.
	String fileName = doc.getOriginalFileName();
	String filePath = fileName.replace("\\", "\\\\");

	// Create the SQL command.
	String commandString = "INSERT INTO Documents (FileName, FileContent) VALUES('" + filePath + "', '" + buffer
			+ "')";
	Statement statement = mConnection.createStatement();
	statement.executeUpdate(commandString);
}

Specificare commandString, che è un’espressione SQL che esegue tutto il lavoro:

• Per salvare un documento nel database, viene utilizzato il comando” INSERT INTO " e viene specificata una tabella insieme ai valori di due campi record: FileName e FileContent. Per evitare parametri aggiuntivi, il nome del file viene preso dall’oggetto Document stesso. Al valore del campo FileContent vengono assegnati byte dal flusso di memoria, che contiene una rappresentazione binaria del documento memorizzato.
• La riga di codice rimanente esegue il comando che memorizza il documento Aspose.Words nel database.

Recuperare un documento da un database

Per recuperare un documento dal database, selezionare il record che contiene i dati del documento come matrice di byte. Quindi caricare l’array di byte dal record in MemoryStream e creare un oggetto Document che caricherà il documento dal MemoryStream.

Il seguente esempio di codice mostra come recuperare e restituire un documento dal database specificato utilizzando il nome file come chiave per recuperare questo documento:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
private static Document ReadFromDatabase(String fileName, Connection mConnection) throws Exception {
	// Create the SQL command.
	String commandString = "SELECT * FROM Documents WHERE FileName=?";
	PreparedStatement statement = mConnection.prepareStatement(commandString);
	statement.setString(1, fileName);

	Document doc = null;
	ResultSet result = statement.executeQuery();
	if (result.next()) {
		Blob blob = result.getBlob("FileContent");
		InputStream inputStream = blob.getBinaryStream();
		doc = new Document(inputStream);
		inputStream.close();
		System.out.println("File saved");
	}
	result.close();
	return doc;
}

Il comando SQL “SELECT * FROM” viene utilizzato per recuperare il record appropriato in base al nome del file.

Eliminare un documento da un database

Per eliminare un documento dal database, utilizzare il comando SQL appropriato senza alcuna manipolazione sull’oggetto Document.

L’esempio di codice seguente mostra come eliminare un documento dal database, utilizzando il nome del file per recuperare il record:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
private static void DeleteFromDatabase(String fileName, Connection mConnection) throws Exception {
	// Create the SQL command.
	String commandString = "DELETE FROM Documents WHERE FileName='" + fileName + "'";
	Statement statement = mConnection.createStatement();
	// Delete the record.
	statement.execute(commandString);
}