Come usare Aspose.Cells for Python via Java in un ambiente Gunicorn+Flask

Questo argomento per principianti mostra come gli sviluppatori possono creare una semplice applicazione (Hello World) usando Aspose.Cells for Python via Java. L’applicazione crea un file Microsoft Excel con le parole Hello World in una cella specificata di un foglio di lavoro.

Preparazione completa dell’ambiente

L’ambiente di esecuzione di esempio di questa guida è Ubuntu: 20.04, puoi adattarlo alla tua situazione reale. Per garantire che gli esempi funzionino correttamente, dobbiamo installare alcuni strumenti necessari nell’ambiente. Di seguito è riportata una breve guida passo passo per aiutarti a completare il processo. Si tenga presente che questa è solo una guida approssimativa e i dettagli specifici possono variare in base al sistema e alle esigenze.

Python

Se non installato, installalo come segue:

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

Controlla versione

python3 --version
pip3 --version

Java

Se non installato, installalo come segue:

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

Controlla versione

java -version

virtualenv ambiente virtuale

L’ambiente virtuale viene installato in base alle tue esigenze effettive. Si consiglia di usare ambienti virtuali per gestire le dipendenze del progetto sia in ambienti di sviluppo che di produzione. Seguire il comando seguente per installare:

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

Creare un ambiente virtuale

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

Avviare l’ambiente virtuale

source myenv/bin/activate

Nota: Se si utilizza un ambiente virtuale, le operazioni seguenti richiedono di attivare prima l’ambiente virtuale corrispondente

Flask

Se non installato, segui il comando seguente per installare:

pip install Flask

Gunicorn

Se non installato, segui il comando seguente per installare:

pip install gunicorn

Jpype

Se non installato, segui il comando seguente per installare:

pip install jpype1

aspose-cells

Se non installato, segui il comando seguente per installare:

pip install aspose-cells

Creazione dell’applicazione Hello World

Per creare l’applicazione Hello World utilizzando l’API di Aspose.Cells:

Crea un’istanza della classe Workbook.
Applica la licenza:
1. Se hai acquistato una licenza, utilizza la licenza nella tua applicazione per accedere a tutte le funzionalità complete di Aspose.Cells
2. Se stai utilizzando la versione di valutazione del componente (se stai usando Aspose.Cells senza licenza), salta questo passaggio.
Creare un nuovo file Microsoft Excel o aprire un file esistente in cui desideri aggiungere/aggiornare del testo.
Accedere a qualsiasi cella di un foglio di lavoro nel file Microsoft Excel.
Inserisci le parole Hello World! in una cella accessibile.
Genera il file modificato di Microsoft Excel.

Gli esempi seguenti dimostrano i passaggi sopra indicati.

Creazione di un’organizzazione

Nell’esempio seguente viene creata una nuova organizzazione da zero, vengono scritte le parole “Ciao mondo!” nella cella A1 del primo foglio di lavoro e il file viene salvato.

Supponiamo di avere un percorso di test “/app”. Completeremo il seguente lavoro sotto questo percorso di test.

File dell’applicazione Flask: 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

File della classe di avvio personalizzata di Gunicorn: 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

Avvia il servizio

Verifica che tutti i pacchetti richiesti dal servizio siano installati, quindi avvia il servizio.

Se usi l’ambiente virtuale python3-venv, devi creare un ambiente virtuale nel percorso di test, avviarlo, e poi installare tutti i pacchetti strumenti necessari.

python custom_gunicorn.py Or python3 custom_gunicorn.py

Controlla i risultati

Apri il browser e visita http://127.0.0.1:5000/.
Inserisci il nome del file che vuoi salvare nella casella di input.
Clicca sul pulsante ‘Genera’ per salvare il file.

Dopo aver fatto ciò, otterrai un file Excel denominato secondo il contenuto inserito nel percorso di test corrente. L’anteprima è la seguente:

todo:image_alt_text

Utilizzo di Docker

Oppure puoi mettere le operazioni sopra riportate in un contenitore Docker. È molto semplice usare Docker per configurare l’ambiente usato dall’esempio. Basta inserire le operazioni sopra nel file Dockerfile.

Ecco un file Dockerfile di riferimento. Elenca alcuni toolkit necessari per costruire l’ambiente.

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

Questo file è principalmente usato per fornire un ambiente di dipendenza per progetti Python. Puoi modificare la versione in questo file secondo le tue esigenze.

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

Files principali

La struttura principale dei file è la seguente:

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

Avviare il contenitore

Puoi avviare il contenitore usando il seguente comando

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

Formati di file supportati Licenza