Seriëler maken en werken met een document in een database

Een van de taken die je nodig hebt om gedaan te krijgen wanneer het werken met documenten is opslaan en ophalen Document objecten van en naar een database. Dit zou bijvoorbeeld nodig zijn als u een type content management systeem zou implementeren. Alle vorige versies van documenten moeten in het databasesysteem worden opgeslagen. De mogelijkheid om documenten op te slaan in de database is ook zeer nuttig wanneer uw applicatie biedt een web-based service.

Aspose.Words biedt een mogelijkheid om een document om te zetten in een byte-array voor verdere werkzaamheden met dit document in een database.

Een document omzetten naar Byte Array

Om een document op te slaan in een database of om een document voor transmissie over het hele web te maken, is het vaak noodzakelijk om het document te serialiseren om een bytearray te verkrijgen.

Serialiseren van een Document object in Aspose.Words:

1. Bewaar het in een MemoryStream de Save methode overbelasting van de Document Klasse.
2. Bel de ToArray methode, die een reeks bytes die het document in bytevorm.

De stappen hierboven kunnen dan worden omgekeerd om de bytes terug te laden in een Document object.

Het geselecteerde opslagformaat is belangrijk om ervoor te zorgen dat de hoogste trouw behouden blijft bij het opslaan en herladen in de Document object. Om deze reden wordt voorgesteld om een reeks OOXML bestandsformaten te gebruiken.

Het voorbeeld hieronder laat zien hoe een serialize Document object om een byte array te verkrijgen, en dan hoe de byte array unserialize om een Document object opnieuw:

// 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);

U kunt het sjabloonbestand van dit voorbeeld downloaden van Aspose.Words GitHub.

Een document opslaan, lezen en verwijderen in een database

Deze sectie laat zien hoe je een document opslaat in een database en laad het dan terug in een Document object om ermee te werken. Voor eenvoud is de bestandsnaam de sleutel die gebruikt wordt om documenten op te slaan en op te halen uit de database. De database bevat twee kolommen. De eerste kolom wordt opgeslagen als een tekenreeks en wordt gebruikt om documenten te identificeren. De tweede kolom wordt opgeslagen als een BLOB object dat het documentobject opslaat in de bytevorm.

Het volgende voorbeeld van code laat zien hoe u een verbinding met een database kunt opzetten en commando’s kunt uitvoeren:

// 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 dit voorbeeld gebruiken we de MySQL database om een Aspose.Words document.

Het volgende voorbeeld van code laat zien hoe je een document in de database opslaat, dan hetzelfde document opnieuw leest, en tenslotte het record dat het document bevat uit de database verwijdert:

// 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();

Een document opslaan in een database

Om een document op te slaan in een database converteert u dit document naar een reeks bytes, zoals beschreven aan het begin van dit artikel. Sla dan deze byte-array op in een databaseveld.

Het volgende voorbeeld van code laat zien hoe u een document in de gespecificeerde database kunt opslaan:

// 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);
}

Geef commandoString op, wat een SQL-expressie is die al het werk doet:

• Om een document op te slaan in de database, wordt het commando “INSERT INNU” gebruikt en een tabel gespecificeerd, samen met de waarden van twee recordvelden “FileName and FileContent.” Om extra parameters te vermijden, wordt de bestandsnaam van de Document Bezwaar tegen zichzelf. De FileContent veldwaarde wordt toegewezen bytes uit de geheugenstroom, die een binaire weergave van het opgeslagen document bevat.
• De resterende regel van code voert het commando uit dat de Aspose.Words document in de database.

Een document uit een database ophalen

Om een document uit de database op te halen, selecteert u de record die de documentgegevens bevat als een reeks bytes. Dan laad de byte array van de record in MemoryStream en een Document object dat het document van de MemoryStream.

Het volgende voorbeeld van code laat zien hoe u een document uit de opgegeven database kunt ophalen en retourneren met behulp van de bestandsnaam als sleutel om dit document op te halen:

// 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;
}

Het SQL-commando “ZELECT * FROM

Een document uit een database verwijderen

Om een document uit de database te verwijderen, gebruik de juiste SQL commando zonder enige manipulaties op de Document object.

Het volgende voorbeeld van code laat zien hoe een document uit de database te verwijderen, met behulp van de bestandsnaam om de record op te halen:

// 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);
}