Overview
GraalVM allows seamless interoperability between Java and Python through its Polyglot capabilities. This enables calling Python code from Java and vice versa, sharing data between languages, and building polyglot applications.
Setup and Dependencies
1. GraalVM Installation
# Download GraalVM from https://www.graalvm.org/ # Set JAVA_HOME to GraalVM directory export JAVA_HOME=/path/to/graalvm export PATH=$JAVA_HOME/bin:$PATH # Install Python support gu install python
2. Maven Dependencies
<dependencies> <dependency> <groupId>org.graalvm.polyglot</groupId> <artifactId>polyglot</artifactId> <version>23.1.0</version> </dependency> <dependency> <groupId>org.graalvm.polyglot</groupId> <artifactId>python</artifactId> <version>23.1.0</version> <type>pom</type> </dependency> </dependencies>
Basic Python Interoperability
1. Simple Python Execution from Java
import org.graalvm.polyglot.*;
import org.graalvm.polyglot.proxy.*;
public class BasicPythonInterop {
public static void main(String[] args) {
try (Context context = Context.newBuilder()
.allowAllAccess(true)
.build()) {
// 1. Execute simple Python code
Value result = context.eval("python", "2 + 3 * 4");
System.out.println("Python calculation result: " + result.asInt());
// 2. Execute Python script with variables
String pythonCode = """
x = 10
y = 20
result = x * y + 15
result
""";
Value scriptResult = context.eval("python", pythonCode);
System.out.println("Script result: " + scriptResult.asInt());
// 3. Call Python built-in functions
Value lenFunction = context.eval("python", "len");
Value length = lenFunction.execute("Hello GraalVM");
System.out.println("String length: " + length.asInt());
}
}
}
2. Calling Python Functions from Java
public class PythonFunctionCalls {
public static void main(String[] args) {
try (Context context = Context.newBuilder()
.allowAllAccess(true)
.build()) {
// Define Python functions
String pythonFunctions = """
def greet(name):
return f"Hello, {name}!"
def calculate_circle_area(radius):
import math
return math.pi * radius ** 2
def process_numbers(numbers):
return {
'sum': sum(numbers),
'average': sum(numbers) / len(numbers),
'max': max(numbers),
'min': min(numbers)
}
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
""";
// Execute the Python code to define functions
context.eval("python", pythonFunctions);
// Get references to Python functions
Value greetFunction = context.getBindings("python").getMember("greet");
Value areaFunction = context.getBindings("python").getMember("calculate_circle_area");
Value processFunction = context.getBindings("python").getMember("process_numbers");
Value fibonacciFunction = context.getBindings("python").getMember("fibonacci");
// Call Python functions from Java
Value greeting = greetFunction.execute("John");
System.out.println("Greeting: " + greeting.asString());
Value area = areaFunction.execute(5.0);
System.out.println("Circle area: " + area.asDouble());
Value stats = processFunction.execute(new int[]{1, 2, 3, 4, 5});
System.out.println("Number stats: " + stats);
Value fib = fibonacciFunction.execute(10);
System.out.println("Fibonacci(10): " + fib.asInt());
}
}
}
Advanced Interoperability Patterns
1. Data Exchange Between Java and Python
import java.util.*;
import java.util.stream.Collectors;
public class DataExchangeExamples {
public static void main(String[] args) {
try (Context context = Context.newBuilder()
.allowAllAccess(true)
.build()) {
// 1. Pass Java objects to Python
Map<String, Object> javaData = new HashMap<>();
javaData.put("name", "John Doe");
javaData.put("age", 30);
javaData.put("scores", Arrays.asList(85, 92, 78, 96));
context.getBindings("python").putMember("java_data", javaData);
String processDataPython = """
# Access Java data in Python
name = java_data['name']
age = java_data['age']
scores = java_data['scores']
# Process the data
average_score = sum(scores) / len(scores)
max_score = max(scores)
# Create result dictionary
result = {
'name': name,
'age': age,
'average_score': average_score,
'max_score': max_score,
'is_adult': age >= 18
}
result
""";
Value pythonResult = context.eval("python", processDataPython);
System.out.println("Python processed data: " + pythonResult);
// 2. Pass complex Java objects
List<Map<String, Object>> users = Arrays.asList(
Map.of("id", 1, "name", "Alice", "active", true),
Map.of("id", 2, "name", "Bob", "active", false),
Map.of("id", 3, "name", "Charlie", "active", true)
);
context.getBindings("python").putMember("users", users);
String filterUsersPython = """
active_users = [user for user in users if user['active']]
user_names = [user['name'] for user in active_users]
{
'active_count': len(active_users),
'active_names': user_names,
'total_users': len(users)
}
""";
Value filterResult = context.eval("python", filterUsersPython);
System.out.println("Filtered users: " + filterResult);
// 3. Get Python data back to Java
String createPythonData = """
import datetime
python_data = {
'timestamp': datetime.datetime.now().isoformat(),
'matrix': [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
'nested': {
'level1': {
'level2': ['a', 'b', 'c']
}
},
'set_data': {1, 2, 3, 4, 5}
}
python_data
""";
Value pythonData = context.eval("python", createPythonData);
// Convert Python data to Java types
String timestamp = pythonData.getMember("timestamp").asString();
Value matrix = pythonData.getMember("matrix");
Value nested = pythonData.getMember("nested");
System.out.println("Timestamp from Python: " + timestamp);
System.out.println("Matrix from Python: " + matrix);
// Iterate through Python list in Java
System.out.println("Matrix elements:");
for (int i = 0; i < matrix.getArraySize(); i++) {
Value row = matrix.getArrayElement(i);
for (int j = 0; j < row.getArraySize(); j++) {
System.out.print(row.getArrayElement(j).asInt() + " ");
}
System.out.println();
}
}
}
}
2. Python Libraries in Java
public class PythonLibrariesInJava {
public static void main(String[] args) {
try (Context context = Context.newBuilder()
.allowAllAccess(true)
.build()) {
// 1. Use NumPy for numerical computations
String numpyExample = """
import numpy as np
# Create arrays
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([10, 20, 30, 40, 50])
# Perform operations
result = {
'sum': np.add(arr1, arr2).tolist(),
'product': np.multiply(arr1, arr2).tolist(),
'mean': float(np.mean(arr1)),
'std_dev': float(np.std(arr1))
}
result
""";
Value numpyResult = context.eval("python", numpyExample);
System.out.println("NumPy result: " + numpyResult);
// 2. Use Pandas for data analysis
String pandasExample = """
import pandas as pd
import numpy as np
# Create DataFrame
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'Diana'],
'Age': [25, 30, 35, 28],
'Salary': [50000, 60000, 70000, 55000],
'Department': ['IT', 'HR', 'IT', 'Finance']
}
df = pd.DataFrame(data)
# Perform analysis
analysis = {
'total_employees': len(df),
'average_age': df['Age'].mean(),
'average_salary': df['Salary'].mean(),
'department_counts': df['Department'].value_counts().to_dict(),
'it_employees': df[df['Department'] == 'IT']['Name'].tolist()
}
analysis
""";
Value pandasResult = context.eval("python", pandasExample);
System.out.println("Pandas analysis: " + pandasResult);
// 3. Use Matplotlib (note: requires display or headless mode)
String matplotlibExample = """
import matplotlib
matplotlib.use('Agg') # Use non-interactive backend
import matplotlib.pyplot as plt
import numpy as np
import io
import base64
# Create a simple plot
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.figure(figsize=(8, 4))
plt.plot(x, y, 'b-', linewidth=2)
plt.title('Sine Wave')
plt.xlabel('X')
plt.ylabel('sin(X)')
plt.grid(True)
# Save to bytes buffer
buf = io.BytesIO()
plt.savefig(buf, format='png', dpi=100)
plt.close()
# Convert to base64 for easy transfer
plot_data = base64.b64encode(buf.getvalue()).decode('utf-8')
{'plot_data': plot_data, 'message': 'Plot generated successfully'}
""";
Value plotResult = context.eval("python", matplotlibExample);
System.out.println("Matplotlib result: " + plotResult.getMember("message"));
// The plot data is available as base64 if you want to save or display it
String plotData = plotResult.getMember("plot_data").asString();
System.out.println("Plot data size: " + plotData.length() + " characters");
}
}
}
Practical Use Cases
Example 1: Machine Learning Integration
import java.util.*;
public class MachineLearningIntegration {
public static class MLService {
private final Context context;
public MLService() {
this.context = Context.newBuilder()
.allowAllAccess(true)
.build();
initializePythonML();
}
private void initializePythonML() {
String setupCode = """
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.datasets import make_classification
import joblib
import os
# Global variables for our model and scaler
model = None
feature_names = None
target_names = None
def train_model(n_estimators=100, test_size=0.2):
global model, feature_names, target_names
# Generate sample data
X, y = make_classification(
n_samples=1000,
n_features=4,
n_informative=2,
n_redundant=0,
n_classes=2,
random_state=42
)
feature_names = [f'feature_{i}' for i in range(X.shape[1])]
target_names = ['class_0', 'class_1']
# Split data
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=test_size, random_state=42
)
# Train model
model = RandomForestClassifier(n_estimators=n_estimators, random_state=42)
model.fit(X_train, y_train)
# Evaluate
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
return {
'accuracy': accuracy,
'training_samples': len(X_train),
'test_samples': len(X_test),
'feature_importance': dict(zip(feature_names, model.feature_importances_))
}
def predict(features):
global model
if model is None:
raise Exception("Model not trained. Call train_model first.")
# Convert to numpy array
import numpy as np
features_array = np.array(features).reshape(1, -1)
prediction = model.predict(features_array)[0]
probability = model.predict_proba(features_array)[0]
return {
'prediction': int(prediction),
'probability_class_0': float(probability[0]),
'probability_class_1': float(probability[1]),
'predicted_class': target_names[prediction]
}
def save_model(path):
global model
if model is None:
raise Exception("Model not trained.")
joblib.dump(model, path)
return f"Model saved to {path}"
def load_model(path):
global model
if os.path.exists(path):
model = joblib.load(path)
return f"Model loaded from {path}"
else:
raise Exception(f"Model file not found: {path}")
""";
context.eval("python", setupCode);
}
public Map<String, Object> trainModel(int nEstimators, double testSize) {
Value trainFunction = context.getBindings("python").getMember("train_model");
Value result = trainFunction.execute(nEstimators, testSize);
return result.as(Map.class);
}
public Map<String, Object> predict(List<Double> features) {
Value predictFunction = context.getBindings("python").getMember("predict");
Value result = predictFunction.execute(features.toArray());
return result.as(Map.class);
}
public String saveModel(String path) {
Value saveFunction = context.getBindings("python").getMember("save_model");
Value result = saveFunction.execute(path);
return result.asString();
}
public String loadModel(String path) {
Value loadFunction = context.getBindings("python").getMember("load_model");
Value result = loadFunction.execute(path);
return result.asString();
}
public void close() {
context.close();
}
}
public static void main(String[] args) {
MLService mlService = new MLService();
try {
// Train the model
Map<String, Object> trainingResult = mlService.trainModel(100, 0.2);
System.out.println("Training Results:");
trainingResult.forEach((key, value) ->
System.out.println(key + ": " + value));
// Make predictions
List<Double> features = Arrays.asList(1.2, -0.5, 0.3, 1.8);
Map<String, Object> prediction = mlService.predict(features);
System.out.println("\nPrediction Results:");
prediction.forEach((key, value) ->
System.out.println(key + ": " + value));
// Save the model
String saveResult = mlService.saveModel("random_forest_model.joblib");
System.out.println("\n" + saveResult);
} finally {
mlService.close();
}
}
}
Example 2: Data Processing Pipeline
import java.util.*;
import java.util.stream.*;
public class DataProcessingPipeline {
public static class DataProcessor {
private final Context context;
public DataProcessor() {
this.context = Context.newBuilder()
.allowAllAccess(true)
.build();
initializePythonProcessing();
}
private void initializePythonProcessing() {
String processingCode = """
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
def process_sales_data(sales_data):
# Convert to DataFrame
df = pd.DataFrame(sales_data)
# Data cleaning and transformation
df['sale_date'] = pd.to_datetime(df['sale_date'])
df['revenue'] = df['quantity'] * df['unit_price']
df['month'] = df['sale_date'].dt.to_period('M')
# Calculate metrics
total_revenue = df['revenue'].sum()
average_transaction = df['revenue'].mean()
unique_customers = df['customer_id'].nunique()
# Monthly breakdown
monthly_sales = df.groupby('month').agg({
'revenue': 'sum',
'quantity': 'sum',
'customer_id': 'nunique'
}).rename(columns={
'customer_id': 'unique_customers'
}).to_dict('records')
# Top products
top_products = df.groupby('product_id').agg({
'revenue': 'sum',
'quantity': 'sum'
}).nlargest(5, 'revenue').to_dict('records')
return {
'summary': {
'total_revenue': float(total_revenue),
'average_transaction_value': float(average_transaction),
'unique_customers': int(unique_customers),
'total_transactions': len(df)
},
'monthly_breakdown': monthly_sales,
'top_products': top_products,
'processing_timestamp': datetime.now().isoformat()
}
def detect_anomalies(sensor_readings, threshold=2.0):
import numpy as np
readings = np.array(sensor_readings)
mean = np.mean(readings)
std = np.std(readings)
# Find anomalies (more than threshold standard deviations from mean)
z_scores = np.abs((readings - mean) / std)
anomalies = z_scores > threshold
anomaly_indices = np.where(anomalies)[0].tolist()
anomaly_values = readings[anomalies].tolist()
return {
'mean': float(mean),
'std_dev': float(std),
'anomaly_count': int(np.sum(anomalies)),
'anomaly_indices': anomaly_indices,
'anomaly_values': anomaly_values,
'threshold_used': threshold
}
def text_analysis(texts):
from collections import Counter
import re
all_words = []
for text in texts:
# Simple word extraction
words = re.findall(r'\\b\\w+\\b', text.lower())
all_words.extend(words)
word_freq = Counter(all_words)
most_common = word_freq.most_common(10)
# Basic metrics
total_words = len(all_words)
unique_words = len(word_freq)
avg_words_per_text = total_words / len(texts)
return {
'total_words': total_words,
'unique_words': unique_words,
'average_words_per_text': avg_words_per_text,
'most_common_words': dict(most_common)
}
""";
context.eval("python", processingCode);
}
public Map<String, Object> processSalesData(List<Map<String, Object>> salesData) {
Value processFunction = context.getBindings("python").getMember("process_sales_data");
Value result = processFunction.execute(salesData);
return result.as(Map.class);
}
public Map<String, Object> detectAnomalies(List<Double> sensorReadings, double threshold) {
Value anomalyFunction = context.getBindings("python").getMember("detect_anomalies");
Value result = anomalyFunction.execute(sensorReadings, threshold);
return result.as(Map.class);
}
public Map<String, Object> analyzeText(List<String> texts) {
Value textFunction = context.getBindings("python").getMember("text_analysis");
Value result = textFunction.execute(texts);
return result.as(Map.class);
}
public void close() {
context.close();
}
}
public static void main(String[] args) {
DataProcessor processor = new DataProcessor();
try {
// Example 1: Sales Data Processing
List<Map<String, Object>> salesData = generateSampleSalesData();
Map<String, Object> salesResult = processor.processSalesData(salesData);
System.out.println("Sales Data Analysis:");
System.out.println(salesResult);
// Example 2: Anomaly Detection
List<Double> sensorData = Arrays.asList(10.1, 10.2, 10.3, 15.8, 10.2, 9.9, 25.1, 10.3);
Map<String, Object> anomalyResult = processor.detectAnomalies(sensorData, 2.0);
System.out.println("\nAnomaly Detection:");
System.out.println(anomalyResult);
// Example 3: Text Analysis
List<String> texts = Arrays.asList(
"The quick brown fox jumps over the lazy dog",
"Machine learning is fascinating and powerful",
"Java and Python integration with GraalVM is amazing"
);
Map<String, Object> textResult = processor.analyzeText(texts);
System.out.println("\nText Analysis:");
System.out.println(textResult);
} finally {
processor.close();
}
}
private static List<Map<String, Object>> generateSampleSalesData() {
List<Map<String, Object>> data = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < 100; i++) {
data.add(Map.of(
"sale_date", "2024-01-" + (random.nextInt(28) + 1),
"customer_id", "cust_" + random.nextInt(50),
"product_id", "prod_" + random.nextInt(20),
"quantity", random.nextInt(5) + 1,
"unit_price", 10 + random.nextDouble() * 90
));
}
return data;
}
}
Example 3: Scientific Computing Bridge
import java.util.*;
public class ScientificComputingBridge {
public static class SciPyService {
private final Context context;
public SciPyService() {
this.context = Context.newBuilder()
.allowAllAccess(true)
.build();
initializeScientificComputing();
}
private void initializeScientificComputing() {
String scipyCode = """
import numpy as np
from scipy import stats
from scipy import optimize
from scipy import integrate
import scipy.signal as signal
def statistical_analysis(data):
data_array = np.array(data)
return {
'mean': float(np.mean(data_array)),
'median': float(np.median(data_array)),
'std_dev': float(np.std(data_array)),
'variance': float(np.var(data_array)),
'skewness': float(stats.skew(data_array)),
'kurtosis': float(stats.kurtosis(data_array)),
'normality_test': {
'statistic': float(stats.normaltest(data_array).statistic),
'pvalue': float(stats.normaltest(data_array).pvalue)
}
}
def optimize_function(coefficients, initial_guess):
# Define a quadratic function to optimize
def quadratic(x):
return coefficients[0]*x**2 + coefficients[1]*x + coefficients[2]
# Find minimum
result = optimize.minimize(quadratic, initial_guess)
return {
'minimum_x': float(result.x[0]),
'minimum_value': float(result.fun),
'success': bool(result.success),
'iterations': int(result.nit)
}
def integrate_function(a, b, function_type='quadratic'):
if function_type == 'quadratic':
def func(x):
return x**2 + 2*x + 1
elif function_type == 'sine':
def func(x):
return np.sin(x)
else:
def func(x):
return np.exp(-x)
result, error = integrate.quad(func, a, b)
return {
'integral_value': float(result),
'absolute_error': float(error),
'interval': [a, b],
'function_type': function_type
}
def signal_processing(signal_data, sample_rate):
signal_array = np.array(signal_data)
# Apply Fourier transform
fft_result = np.fft.fft(signal_array)
frequencies = np.fft.fftfreq(len(signal_array), 1/sample_rate)
# Filter the signal (low-pass)
b, a = signal.butter(4, 0.1, 'low')
filtered_signal = signal.filtfilt(b, a, signal_array)
# Find peaks
peaks, properties = signal.find_peaks(signal_array, height=0.5)
return {
'original_signal': signal_array.tolist(),
'filtered_signal': filtered_signal.tolist(),
'dominant_frequencies': frequencies[:len(frequencies)//2].tolist(),
'fft_magnitude': np.abs(fft_result[:len(fft_result)//2]).tolist(),
'peaks_count': len(peaks),
'peak_positions': peaks.tolist(),
'peak_heights': properties['height'].tolist()
}
def solve_ode(initial_condition, time_span):
# Simple ODE: dy/dt = -2y
def ode_func(t, y):
return -2 * y
from scipy.integrate import solve_ivp
solution = solve_ivp(ode_func, time_span, [initial_condition],
t_eval=np.linspace(time_span[0], time_span[1], 100))
return {
'time_points': solution.t.tolist(),
'solution': solution.y[0].tolist(),
'initial_condition': initial_condition,
'time_span': time_span
}
""";
context.eval("python", scipyCode);
}
public Map<String, Object> statisticalAnalysis(List<Double> data) {
Value statsFunction = context.getBindings("python").getMember("statistical_analysis");
Value result = statsFunction.execute(data);
return result.as(Map.class);
}
public Map<String, Object> optimizeFunction(List<Double> coefficients, double initialGuess) {
Value optimizeFunction = context.getBindings("python").getMember("optimize_function");
Value result = optimizeFunction.execute(coefficients.toArray(), initialGuess);
return result.as(Map.class);
}
public Map<String, Object> integrateFunction(double a, double b, String functionType) {
Value integrateFunction = context.getBindings("python").getMember("integrate_function");
Value result = integrateFunction.execute(a, b, functionType);
return result.as(Map.class);
}
public Map<String, Object> processSignal(List<Double> signalData, double sampleRate) {
Value signalFunction = context.getBindings("python").getMember("signal_processing");
Value result = signalFunction.execute(signalData, sampleRate);
return result.as(Map.class);
}
public Map<String, Object> solveODE(double initialCondition, List<Double> timeSpan) {
Value odeFunction = context.getBindings("python").getMember("solve_ode");
Value result = odeFunction.execute(initialCondition, timeSpan.toArray());
return result.as(Map.class);
}
public void close() {
context.close();
}
}
public static void main(String[] args) {
SciPyService scipy = new SciPyService();
try {
// Statistical Analysis
List<Double> data = Arrays.asList(1.2, 2.3, 1.8, 3.1, 2.7, 1.5, 2.9, 3.2, 2.1, 1.7);
Map<String, Object> stats = scipy.statisticalAnalysis(data);
System.out.println("Statistical Analysis:");
stats.forEach((key, value) -> System.out.println(key + ": " + value));
// Optimization
List<Double> coefficients = Arrays.asList(1.0, -4.0, 4.0);
Map<String, Object> optimization = scipy.optimizeFunction(coefficients, 0.0);
System.out.println("\nOptimization Results:");
optimization.forEach((key, value) -> System.out.println(key + ": " + value));
// Integration
Map<String, Object> integration = scipy.integrateFunction(0, 2, "quadratic");
System.out.println("\nIntegration Results:");
integration.forEach((key, value) -> System.out.println(key + ": " + value));
// Signal Processing
List<Double> signal = generateSampleSignal();
Map<String, Object> signalResult = scipy.processSignal(signal, 100.0);
System.out.println("\nSignal Processing - Peaks found: " + signalResult.get("peaks_count"));
// ODE Solving
Map<String, Object> odeResult = scipy.solveODE(1.0, Arrays.asList(0.0, 5.0));
System.out.println("\nODE Solution computed for " +
((List<?>) odeResult.get("time_points")).size() + " time points");
} finally {
scipy.close();
}
}
private static List<Double> generateSampleSignal() {
List<Double> signal = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
double t = i / 100.0;
signal.add(Math.sin(2 * Math.PI * 5 * t) + 0.5 * Math.sin(2 * Math.PI * 20 * t));
}
return signal;
}
}
Performance Optimization
1. Context Reuse and Caching
public class OptimizedGraalVMUsage {
private static final Context SHARED_CONTEXT = Context.newBuilder()
.allowAllAccess(true)
.build();
static {
// Pre-load commonly used Python code
String commonLibraries = """
import numpy as np
import pandas as pd
from scipy import stats
# Cache frequently used functions
cached_functions = {
'stats': stats,
'np': np,
'pd': pd
}
""";
SHARED_CONTEXT.eval("python", commonLibraries);
}
public static class OptimizedProcessor {
private final Value cachedFunction;
public OptimizedProcessor(String functionName, String functionCode) {
// Define the function once
SHARED_CONTEXT.eval("python", functionCode);
this.cachedFunction = SHARED_CONTEXT.getBindings("python").getMember(functionName);
}
public Value execute(Object... args) {
return cachedFunction.execute(args);
}
}
public static void main(String[] args) {
// Create optimized processors
OptimizedProcessor statsProcessor = new OptimizedProcessor("calculate_stats", """
def calculate_stats(data):
import numpy as np
return {
'mean': float(np.mean(data)),
'std': float(np.std(data)),
'min': float(np.min(data)),
'max': float(np.max(data))
}
""");
// Reuse the same processor multiple times
for (int i = 0; i < 10; i++) {
List<Double> data = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0);
Value result = statsProcessor.execute(data.toArray());
System.out.println("Iteration " + i + ": " + result);
}
}
}
Error Handling and Best Practices
import org.graalvm.polyglot.PolyglotException;
public class ErrorHandlingExamples {
public static void safePythonExecution() {
try (Context context = Context.newBuilder()
.allowAllAccess(true)
.build()) {
try {
// This will cause a Python error
Value result = context.eval("python", """
undefined_variable * 2
""");
System.out.println("Result: " + result);
} catch (PolyglotException e) {
System.err.println("Python execution failed:");
System.err.println(" Message: " + e.getMessage());
System.err.println(" Language: " + e.getSourceLocation().getLanguage());
System.err.println(" Line: " + e.getSourceLocation().getStartLine());
if (e.isHostException()) {
System.err.println(" Host exception: " + e.asHostException());
}
}
// Graceful error handling with try-catch in Python
String safeCode = """
try:
result = undefined_variable * 2
except NameError as e:
result = f"Error handled in Python: {e}"
result
""";
Value safeResult = context.eval("python", safeCode);
System.out.println("Safe execution: " + safeResult.asString());
}
}
public static void resourceManagement() {
// Using try-with-resources for automatic context cleanup
try (Context context = Context.newBuilder()
.allowAllAccess(true)
.build()) {
// Perform operations
Value result = context.eval("python", "42 * 2");
System.out.println("Result: " + result.asInt());
} // Context automatically closed here
// Context is no longer usable after close()
try {
Context closedContext = Context.newBuilder().build();
closedContext.close();
closedContext.eval("python", "1 + 1"); // This will throw IllegalStateException
} catch (IllegalStateException e) {
System.out.println("Correctly prevented use of closed context");
}
}
public static void main(String[] args) {
safePythonExecution();
resourceManagement();
}
}
Best Practices Summary
- Context Management: Always use try-with-resources for Context objects
- Function Caching: Cache frequently used Python functions for better performance
- Error Handling: Implement comprehensive error handling for Python exceptions
- Resource Cleanup: Ensure proper cleanup of Python resources
- Type Safety: Be mindful of type conversions between Java and Python
- Memory Management: Monitor memory usage when working with large datasets
- Dependency Management: Ensure Python dependencies are available in the environment
GraalVM provides a powerful bridge between Java and Python, enabling you to leverage Python's rich ecosystem of libraries while maintaining the performance and type safety of Java applications.