Wie man Aspose.Cells for Python via Java in Gunicorn+Flask Umgebung verwendet

Dieses Anfänger-Thema zeigt, wie Entwickler eine einfache Anwendung (Hallo Welt) mit Aspose.Cells for Python via Java erstellen können. Die Anwendung erstellt eine Microsoft Excel-Datei mit dem Text Hallo Welt in einer bestimmten Zelle eines Arbeitsblatts.

Vollständige Umgebungs Vorbereitung

Die Beispiel-Umgebung dieses Leitfadens ist Ubuntu: 20.04, Sie können sie an Ihre tatsächliche Situation anpassen. Um sicherzustellen, dass die Beispiele ordnungsgemäß ausgeführt werden, müssen wir einige notwendige Tools in der Umgebung installieren. Das folgende ist eine kurze Schritt-für-Schritt-Anleitung, um den Vorgang abzuschließen. Bitte beachten Sie, dass dies nur eine grobe Anleitung ist und die konkreten Details je nach System und Bedarf variieren können.

Python

Falls nicht installiert, installieren Sie es wie folgt:

sudo apt install python3 python3-pip # Ubuntu/Debian
#sudo yum install python3 python3-pip # CentOS/RHEL

Versionsprüfung

python3 --version
pip3 --version

Java

Falls nicht installiert, installieren Sie es wie folgt:

sudo apt install openjdk-11-jdk # Ubuntu/Debian
#sudo yum install java-17-openjdk # CentOS/RHEL
ENV JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
ENV PATH=$JAVA_HOME/bin:$PATH

Versionsprüfung

java -version

virtualenv virtuelle Umgebung

Die virtuelle Umgebung wird basierend auf Ihren tatsächlichen Bedürfnissen installiert. Es wird empfohlen, virtuelle Umgebungen zur Verwaltung von Projektabhängigkeiten sowohl in Entwicklungs- als auch in Produktionsumgebungen zu verwenden. Bitte folgen Sie dem folgenden Befehl, um zu installieren:

sudo apt install python3-venv # Ubuntu/Debian
#sudo yum install python3-venv # CentOS/RHEL

Erstellen Sie eine virtuelle Umgebung

python3 -m venv myenv # Create a virtual environment named myenv in the current directory

Starten Sie die virtuelle Umgebung

source myenv/bin/activate

Hinweis: Wenn eine virtuelle Umgebung verwendet wird, erfordern die folgenden Operationen zuerst die Aktivierung der entsprechenden virtuellen Umgebung

Flask

Wenn nicht installiert, folgen Sie bitte dem folgenden Befehl zur Installation:

pip install Flask

Gunicorn

Wenn nicht installiert, folgen Sie bitte dem folgenden Befehl zur Installation:

pip install gunicorn

Jpype

Wenn nicht installiert, folgen Sie bitte dem folgenden Befehl zur Installation:

pip install jpype1

aspose-cells

Wenn nicht installiert, folgen Sie bitte dem folgenden Befehl zur Installation:

pip install aspose-cells

Erstellen der Hello World-Anwendung

Um die Hello World-Anwendung mit der Aspose.Cells-API zu erstellen:

Erstellen Sie eine Instanz der Klasse Workbook.
Lizenz anwenden:
1. Wenn Sie eine Lizenz erworben haben, verwenden Sie die Lizenz in Ihrer Anwendung, um auf die volle Funktionalität von Aspose.Cells zuzugreifen.
2. Wenn Sie die Evaluierungsversion des Komponenten verwenden (wenn Sie Aspose.Cells ohne Lizenz verwenden), überspringen Sie diesen Schritt.
Erstellen Sie eine neue Microsoft Excel-Datei oder öffnen Sie eine vorhandene Datei, in der Sie einige Texte hinzufügen/aktualisieren möchten.
Greifen Sie auf eine Zelle eines Arbeitsblatts in der Microsoft Excel-Datei zu.
Fügen Sie die Worte Hallo Welt! in eine zugängliche Zelle ein.
Generieren Sie die modifizierte Microsoft Excel-Datei.

Die folgenden Beispiele demonstrieren die obigen Schritte.

Erstellen eines Arbeitsblatts

Das folgende Beispiel erstellt ein neues Arbeitsblatt von Grund auf, schreibt die Worte ‘Hallo Welt!’ in die Zelle A1 des ersten Arbeitsblatts und speichert die Datei.

Angenommen, wir haben einen Testpfad “/app”. Wir werden die folgenden Arbeiten unter diesem Testpfad durchführen.

Flask-Anwendungsdateien: hello.py


	from flask import Flask, request, jsonify
	import threading

	# Creating a Flask Application
	def create_app():
	print("Start create_app")
	app = Flask(__name__)

	@app.route("/")
	def home():
	# Returns HTML page content
	return """
	<!DOCTYPE html>
	<html>
	<head>
	<title>Aspose.Cells Python via Java in Flask</title>
	</head>
	<body>
	<h1>Welcome to Aspose.Cells Python via Java</h1>
	<p>This is an example of how to use Aspose.Cells Python via Java in Flask.</p>
	<p>This example creates a new workbook object and enters "Hello World" in the specified cell, and finally saves it with the file name you specify.</p>

	<pre><code>
	import jpype
	import asposecells
	if not jpype.isJVMStarted():
	jpype.startJVM()
	from asposecells.api import Workbook, CellsHelper
	workbook = Workbook()
	workbook.getWorksheets().get(0).getCells().get("A1").putValue("Hello World")
	workbook.save("NameYouSpecified" + ".xlsx")
	</code></pre>

	<label>Enter Your File Name:</label>
	<input type="text" id="name" name="name" required>
	<button id="btn_save">Generate</button>
	<p id="message"></p>
	<script>
	//Bind a click event to button Save
	document.getElementById("btn_save").addEventListener("click", function() {
	var name = document.getElementById('name').value;
	fetch("/button_save?name=" + encodeURIComponent(name))
	.then(response => response.json())
	.then(data => {
	document.getElementById("message").innerText = "The generated file is saved as " + data.FileName + ".xlsx";
	});
	});
	</script>
	</body>
	</html>
	"""


	@app.route("/button_save", methods=["GET"])
	def increment_button1():
	"""Handle the click event of button Save"""

	import jpype
	import asposecells
	if not jpype.isJVMStarted():
	jpype.startJVM()
	from asposecells.api import Workbook, CellsHelper

	#print("Version: " + CellsHelper.getVersion())

	workbook = Workbook()
	workbook.getWorksheets().get(0).getCells().get("A1").putValue("Hello World")
	name = request.args.get('name')
	workbook.save(str(name) + ".xlsx")

	return jsonify({"message": "Button Save clicked", "FileName": str(name)})

	return app

view raw CreatingHelloWorldFileInFlask1.py hosted with ❤ by GitHub

Benutzerdefinierte Gunicorn-Startklassen-Datei: custom_gunicorn.py

	from gunicorn.app.base import BaseApplication
	from hello import create_app

	class CustomGunicornApplication(BaseApplication):
	"""
	Customizing the Gunicorn Startup Class
	"""

	def __init__(self, app, options=None):
	self.app = app
	self.options = options or {}
	super().__init__()

	def load_config(self):
	"""Loading Gunicorn’s configuration"""
	for key, value in self.options.items():
	self.cfg.set(key.lower(), value)

	def load(self):
	"""Loading the Flask application"""
	return self.app

	def on_starting(self, server):
	"""Fired when the Gunicorn main process starts"""
	print("Gunicorn is starting... Running some initialization tasks...")
	self.initialize_system()

	def initialize_system(self):
	"""Perform certain tasks at startup, such as logging or loading resources"""
	print("System initialized!")

	if __name__ == "__main__":
	# Creating a Flask Application
	app = create_app()

	# Gunicorn Configuration
	gunicorn_options = {
	"bind": "0.0.0.0:5000", # Bind address and port
	"workers": 2, # Number of worker processes
	"loglevel": "info", # Log level
	}

	# Starting a custom Gunicorn application
	CustomGunicornApplication(app, gunicorn_options).run()

view raw CreatingHelloWorldFileInFlask2.py hosted with ❤ by GitHub

Dienst starten

Stellen Sie sicher, dass alle für den Dienst erforderlichen Pakete installiert sind, und starten Sie dann den Dienst.

Wenn Sie die virtuelle Umgebung python3-venv verwenden, müssen Sie im Testpfad eine virtuelle Umgebung erstellen, diese starten und dann alle erforderlichen Tool-Pakete installieren.

python custom_gunicorn.py Or python3 custom_gunicorn.py

Ergebnisse überprüfen

1Öffnen Sie den Browser und besuchen Sie http://127.0.0.1:5000/.

2 Geben Sie den Dateinamen, den Sie speichern möchten, in das Eingabefeld ein.

3 Klicken Sie auf die Schaltfläche ‘Generieren’, um die Datei zu speichern.

Nachdem Sie dies getan haben, erhalten Sie eine Excel-Datei, die nach dem eingegebenen Inhalt im aktuellen Testpfad benannt ist. Die Vorschau sieht wie folgt aus:

todo:image_alt_text

Verwendung von Docker

Oder Sie können die oben genannten Operationen in einem Docker-Container durchführen. Es ist sehr einfach, Docker zum Aufbau der Umgebung zu verwenden, die im Beispiel verwendet wird. Legen Sie dazu die oben genannten Operationen in die Dockerfile-Datei.

Hier ist eine Dockerfile-Datei zur Referenz. Sie listet einige notwendige Toolkits auf, die zum Aufbau der Umgebung erforderlich sind.

Dockerfile

FROM ubuntu:20.04
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    python3-dev \
    python3-venv \
    build-essential \
    libssl-dev \
    libffi-dev \
    libpq-dev \
    openjdk-11-jdk \
    wget \
    curl \
    unzip \
    && rm -rf /var/lib/apt/lists/*
ENV JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
ENV PATH=$JAVA_HOME/bin:$PATH
WORKDIR /app
COPY . /app
RUN pip install -r requirements.txt
CMD ["python3", "custom_gunicorn.py"]

requirements.txt

Diese Datei wird hauptsächlich verwendet, um eine Abhängigkeitsumgebung für Python-Projekte bereitzustellen. Sie können die Version in dieser Datei nach Ihren Bedürfnissen ändern.

aspose-cells==24.11.0
jpype1==1.5.1
Flask==3.0.3
gunicorn==23.0.0

Hauptdateien

Die Hauptdateistruktur ist wie folgt:

app/
|-requirements.txt
|-hello.py
|-custom_gunicorn.py

Container starten

Sie können den Container mit folgendem Befehl starten

docker run --rm -p 127.0.0.1:5000:5000 gunicorn_flask:v1.0 # gunicorn_flask:v1.0 - Image built by Dockerfile

Unterstützte Dateiformate Lizenzierung