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

1. Context Management: Always use try-with-resources for Context objects
2. Function Caching: Cache frequently used Python functions for better performance
3. Error Handling: Implement comprehensive error handling for Python exceptions
4. Resource Cleanup: Ensure proper cleanup of Python resources
5. Type Safety: Be mindful of type conversions between Java and Python
6. Memory Management: Monitor memory usage when working with large datasets
7. 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.