Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/benanders/rjni

Run Java code from Rust!
https://github.com/benanders/rjni

java java-native-interface jvm rust

Last synced: about 2 months ago
JSON representation

Run Java code from Rust!

Awesome Lists containing this project

README

        

Java Native Interface Bindings for Rust
=======================================

This library provides complete FFI bindings to the Java Native Interface, as
well as a safe and intuitive wrapper around most these bindings (lacking array
support for now).

Features include:

* Creating and configuring an instance of a Java Virtual Machine
* Loading classes
* Calling static methods on classes
* Setting and retrieving public static fields on classes
* Instantiating objects from a class
* Calling methods on objects
* Setting and retrieving public fields on objects
* Using all primitive Java types and other Java objects as arguments and
return values (no support for arrays yet)

### Documentation

Documentation can be found [here](https://benanderson.io/docs/rjni).

### Usage

First you'll need to compile your Java source code, either as separate `.class`
files, or package them together as a `.jar` archive.

You need to make sure you target the Java compiler to the JVM version you plan
to use. This is done through the `-target` and `-source` command line arguments
to `javac`.

For example, if you have a `/path/to/project/com/me/Test.java` file (ie. the
class `com.me.Test`) and you intend to target the 1.6 JVM:

```bash
$ javac -target 1.6 -source 1.6 /path/to/project/com/me/Test.java
```

This will create a `/path/to/project/com/me/Test.class` file.

Then when you create the JVM in Rust, you need to add `/path/to/project` (ie.
the directory containing the root of your Java code) to the classpath, and
specify the correct JVM version:

```rust
use rjni::{Jvm, Version, Classpath, Options};

fn main() {
// Create a custom classpath, pointing to the directory containing the root
// of your Java code
let mut classpath = Classpath::new();
classpath.add(&Path::new("/path/to/project"));

// Create a series of configuration options for the JVM, specifying the
// version of the JVM we want to use (1.6), and our custom classpath
let mut options = Options::new();
options.version(Version::V16);
options.classpath(classpath);

// Create the JVM with these options
let jvm = Jvm::new(options).unwrap();

// Get the `com.me.Test` class using the JVM
let class = jvm.class("com/me/Test").unwrap();

// ...
}
```

See the `examples` folder for more example code on how to call static methods
on classes, instantiate objects, call methods on objects, and access object
fields.