Serialisieren und Arbeiten mit einem Dokument in einer Datenbank
Eine der Aufgaben, die Sie möglicherweise bei der Arbeit mit Dokumenten erledigen müssen, ist das Speichern und Abrufen von Document -Objekten in und aus einer Datenbank. Dies wäre beispielsweise erforderlich, wenn Sie irgendeine Art von Content-Management-System implementieren würden. Alle vorherigen Versionen von Dokumenten müssen im Datenbanksystem gespeichert sein. Die Möglichkeit, Dokumente in der Datenbank zu speichern, ist auch äußerst nützlich, wenn Ihre Anwendung einen webbasierten Dienst bereitstellt.
Aspose.Words bietet die Möglichkeit, ein Dokument in ein Byte-Array zu konvertieren, um anschließend mit diesem Dokument in einer Datenbank zu arbeiten.
Konvertieren eines Dokuments in ein Byte-Array
Um ein Dokument in einer Datenbank zu speichern oder ein Dokument für die Übertragung über das Web vorzubereiten, ist es häufig erforderlich, das Dokument zu serialisieren, um ein Byte-Array zu erhalten.
So serialisieren Sie ein Document -Objekt in Aspose.Words:
- Speichern Sie es mit der Save -Methodenüberladung der Document -Klasse in einem MemoryStream.
- Rufen Sie die Methode ToArray auf, die ein Array von Bytes zurückgibt, die das Dokument in Byteform darstellen.
Die obigen Schritte können dann umgekehrt werden, um die Bytes wieder in ein Document -Objekt zu laden.
Das folgende Beispiel zeigt, wie ein Document -Objekt serialisiert wird, um ein Byte-Array zu erhalten, und dann, wie das Byte-Array deserialisiert wird, um wieder ein Document -Objekt zu erhalten:
// 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); |
Speichern, Lesen und Löschen eines Dokuments in einer Datenbank
Dieser Abschnitt zeigt, wie Sie ein Dokument in einer Datenbank speichern und es dann wieder in ein Document
-Objekt laden, um damit zu arbeiten. Der Einfachheit halber ist der Dateiname der Schlüssel zum Speichern und Abrufen von Dokumenten aus der Datenbank. Die Datenbank enthält zwei Spalten. Die erste Spalte “FileName” wird als Zeichenfolge gespeichert und dient zur Identifizierung von Dokumenten. Die zweite Spalte “FileContent” wird als BLOB
-Objekt gespeichert, in dem das Dokumentobjekt in Byteform gespeichert ist.
Das folgende Codebeispiel zeigt, wie Sie eine Verbindung zu einer Datenbank herstellen und Befehle ausführen:
// 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); |
Das folgende Codebeispiel zeigt, wie Sie ein Dokument in der Datenbank speichern, dann dasselbe Dokument erneut lesen und schließlich den Datensatz mit dem Dokument aus der Datenbank löschen:
// 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(); |
Speichern eines Dokuments in einer Datenbank
Um ein Dokument in einer Datenbank zu speichern, konvertieren Sie dieses Dokument in ein Array von Bytes, wie am Anfang dieses Artikels beschrieben. Speichern Sie dann dieses Byte-Array in einem Datenbankfeld.
Das folgende Codebeispiel zeigt, wie ein Dokument in der angegebenen Datenbank gespeichert wird:
// 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); | |
} |
Geben Sie commandString an, was ein SQL-Ausdruck ist, der die ganze Arbeit erledigt:
- Um ein Dokument in der Datenbank zu speichern, wird der Befehl “INSERT INTO” verwendet und eine Tabelle zusammen mit den Werten von zwei Datensatzfeldern – FileName und FileContent - angegeben. Um zusätzliche Parameter zu vermeiden, wird der Dateiname vom Document-Objekt selbst übernommen. Dem Feldwert
FileContent
werden Bytes aus dem Speicherstrom zugewiesen, der eine binäre Darstellung des gespeicherten Dokuments enthält. - Die verbleibende Codezeile führt den Befehl aus, der das Aspose.Words -Dokument in der Datenbank speichert.
Abrufen eines Dokuments aus einer Datenbank
Um ein Dokument aus der Datenbank abzurufen, wählen Sie den Datensatz, der die Dokumentdaten enthält, als Byte-Array aus. Laden Sie dann das Byte-Array aus dem Datensatz in MemoryStream und erstellen Sie ein Document -Objekt, das das Dokument aus MemoryStream lädt.
Das folgende Codebeispiel zeigt, wie ein Dokument aus der angegebenen Datenbank abgerufen und zurückgegeben wird, wobei der Dateiname als Schlüssel zum Abrufen dieses Dokuments verwendet wird:
// 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; | |
} |
Löschen eines Dokuments aus einer Datenbank
Um ein Dokument aus der Datenbank zu löschen, verwenden Sie den entsprechenden SQL -Befehl, ohne das Document-Objekt zu bearbeiten.
Das folgende Codebeispiel zeigt, wie ein Dokument aus der Datenbank gelöscht wird, wobei der Dateiname zum Abrufen des Datensatzes verwendet wird:
// 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); | |
} |