1. Introduction

This plugin enables the usage of the Java RMI protocol on a Griffon application.

Griffon version: 2.2.0

2. Usage

The following sections describe how you may use this plugin in an project.

2.1. Configuration

The plugin’s module registers a RmiHandler helper class that defines the base contract for issuing RMI calls using an appropriate client class. This helper class has the following methods

<R> R withRmi(@Nonnull Map<String, Object> params, @Nonnull RmiClientCallback<R> callback) throws RmiException;

void destroyRmiClient(@Nonnull String clientId);

The following properties must be defined:


The host on which remote objects haven been registered. String. Default localhost.


The port on which objects were exported. Integer. Default 1099.


Attempt a connection to the RMI registry as late as possible. Boolean. Default true.

These methods will create a new client when invoked unless you define an id: attribute. When this attribute is supplied the client will be stored in a cache managed by their respective storage classes (RmiClientStorage).

You can inject an instance of RmiHandler anywhere it’s needed using @Inject.

The RmiClientCallback callback is defined using a functional interface approach, which means you can apply lambda expressions if running with JDK8+ or closures if running Groovy.

    R handle(@Nonnull Map<String, Object> params, @Nonnull RmiClient client) throws RmiException;

2.2. Example

The following is a trivial usage of the RmiHandler inside a service

import griffon.core.GriffonApplication;
import griffon.core.artifact.GriffonService;
import griffon.exceptions.GriffonException;
import griffon.metadata.ArtifactProviderFor;
import griffon.plugins.rmi.exceptions.RmiException;
import griffon.util.CollectionUtils;
import org.codehaus.griffon.runtime.core.artifact.AbstractGriffonService;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.inject.Inject;
import java.rmi.RemoteException;
import java.util.Map;

public class CalculatorService extends AbstractGriffonService {
    private RmiHandler rmiHandler;

    public CalculatorService(@Nonnull GriffonApplication application) {

    public Double calculate(final double num1, final double num2) {
        Map<String, Object> params = CollectionUtils.<String, Object>map()
            .e("id", "client");
        return rmiHandler.withRmi(params,
            new RmiClientCallback<Double>() {
                public Double handle(@Nonnull Map<String, Object> params, @Nonnull RmiClient client) throws RmiException {
                    return client.service(Calculator.NAME, new UnaryConsumer<Calculator, Double>() {
                        public Double consume(Calculator calculator) {
                            try {
                                return calculator.add(num1, num2);
                            } catch (RemoteException e) {
                                throw new GriffonException(e);

Here’s the Groovy version of the same service

import griffon.core.artifact.GriffonService
import griffon.metadata.ArtifactProviderFor

import javax.inject.Inject

class GroovyCalculatorService {
    private RmiHandler rmiHandler

    Double calculate(double num1, double num2) {
        Map params = [id: 'client', port: 1199]
        rmiHandler.withRmi(params, { Map<String, Object> ps, RmiClient client ->
            client.service(Calculator.NAME) { Calculator calculator ->
                calculator.add(num1, num2)

2.3. AST Transformation

You can apply the @RmiAware AST transformation on any class. This injects the behavior of RmiHandler into said class.

2.4. DSL Descriptors

This plugin provides DSL descriptors for Intellij IDEA and Eclipse (provided you have the Groovy Eclipse plugin installed). These descriptors are found inside the griffon-rmi-groovy-compile-1.0.0.jar, with locations

  • dsdl/griffon_rmi.dsld

  • gdsl/griffon_rmi.gdsl

3. Build Configuration

3.1. Gradle

You have two options for configuring this plugin: automatic and manual.

3.1.1. Automatic

As long as the project has the org.codehaus.griffon.griffon plugin applied to it you may include the following snippet in build.gradle

dependencies {
    griffon 'org.codehaus.griffon.plugins:griffon-rmi-plugin:1.0.0'

The griffon plugin will take care of the rest given its configuration.

3.1.2. Manual

You will need to configure any of the following blocks depending on your setup

dependencies {
    compile 'org.codehaus.griffon.plugins:griffon-rmi-core:1.0.0'
Compile Only
dependencies {
    compileOnly 'org.codehaus.griffon.plugins:griffon-rmi-groovy-compile:1.0.0'

3.2. Maven

First configure the griffon-rmi-plugin BOM in your POM file, by placing the following snippet before the <build> element


Next configure dependencies as required by your particular setup

Provided scope

Don’t forget to configure all -compile dependencies with the maven-surefire-plugin, like so


4. Modules

The following sections display all bindings per module. Use this information to successfully override a binding on your own modules or to troubleshoot a module binding if the wrong type has been applied by the Griffon runtime.

4.1. Rmi

Module name: rmi