Remote Procedure Calls between .NET and Java using TCP

Simple example showing RPC communication between .NET and Java.

The source code for this example can be downloaded from:
http://www.eneter.net/Downloads/Examples/RpcCalculatorJavaService.zip

To use the example please download Eneter for .NET and Java from http://www.eneter.net/ProductDownload.htm and add the Eneter library into the project.

Introduction

This article is a free continuation of Remote Procedure Calls between Android and .NET where Android is a client application and .NET is a service application.

The example bellow demonstrates how to use RPC between .NET and Java where .NET is the client application and Java is the service application.

RPC between .NET and Java

As already described in the previous article RPC is a request-response communication where one application (typically client) requests to invoke a method in another application (typically service).

Therefore the key aspect in RPC is exposing methods which can be remotely invoked. The Eneter framework allows to specify these methods via the 'interface' keyword which is supported by both Java and C# languages.

For declaring the interface that shall work across .NET and Java it is important declarations in both environments are identical.

• Methods must have same names (names are case sensitive).
• Input parameters must be of same types.
• Input parameters must be in same order.

Due to language differences there are also following restrictions:

• Generics are not supported.
• Overloading of methods is not allowed.

In general to declare, expose and use the interface between .NET and Java you need to do following steps:

On the service side:

1. Declare API interface that shall be exposed (see ICalculator interface in Java).
2. Provide implementation for the interface (see Calculator class).
3. Use Eneter to expose the interface (see using RpcFactory instantiating IRpcService).
4. Use Eneter to start listening via TCP, WebSocket or UDP (see attaching the input channel to IRpcService).

On the client side:

1. Declare identical API interface as in the service (see ICalculator interface in C#).
2. Use Eneter to provide the proxy implementation for the interface (see using RpcFactory instantiating IRpcClient).
3. Use Eneter to connect the proxy implementation with the service (see attaching the output channel to IRpcClient).
4. Use the 'Proxy' property to call methods from the interface.

Java Service Application

The service is a simple console application that calculates numbers. It exposes ICalculation interface which declares methods that can be called from a .NET application.

Declaration of the interface:

/**
 * Declares calculator service methods.
 */
public interface ICalculator
{
    double sum(double a, double b);
    double subtract(double a, double b);
    double multiplay(double a, double b);
    double divide(double a, double b);
}

Implementation of the interface:

/**
 * Implements service methods.
 */
public class Calculator implements ICalculator
{
    @Override
    public double sum(double a, double b)
    {
        return a + b;
    }

    @Override
    public double subtract(double a, double b)
    {
        return a - b;
    }

    @Override
    public double multiplay(double a, double b)
    {
        return a * b;
    }

    @Override
    public double divide(double a, double b)
    {
        return a / b;
    }
}

Listening console application exposing the interface:

package calculator;

import java.io.*;

import eneter.messaging.endpoints.rpc.*;
import eneter.messaging.messagingsystems.messagingsystembase.*;
import eneter.messaging.messagingsystems.tcpmessagingsystem.TcpMessagingSystemFactory;

public class Program
{
    public static void main(String[] args) throws Exception
    {
        // Instantiate the calculator.
        Calculator aCalculator = new Calculator();
        
        // Expose the calculator as a service.
        RpcFactory anRpcFactory = new RpcFactory();
        IRpcService<ICalculator> aService =
            anRpcFactory.createSingleInstanceService(aCalculator, ICalculator.class);
        
        // Use TCP.
        // Note: You can use other protocols e.g. WebSockets too.
        IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
        IDuplexInputChannel anInputChannel =
            aMessaging.createDuplexInputChannel("tcp://127.0.0.1:8045/");
        
        // Attach input channel and start listening.
        aService.attachDuplexInputChannel(anInputChannel);
        
        System.out.println("Calculator service is running. Press ENTER to stop.");
        new BufferedReader(new InputStreamReader(System.in)).readLine();
        
        // Detach input channel and stop listening.
        aService.detachDuplexInputChannel();
    }
}

.NET Client Application

The client is a simple WinForm application using the Java service to calculate numbers. It declares the same interface like the Java service and uses RPC from Eneter framework to communicate with the Java service.

The whole implementation is very simple:

using System;
using System.Windows.Forms;
using Eneter.Messaging.EndPoints.Rpc;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace CalculatorClient2
{
    public partial class Form1 : Form
    {
        // Declare same interface as in Java service application.
        // Note: do not forget case-sensitiveness. If Java methods start with
        //       small letters then also these methods must start with small letters.
        public interface ICalculator
        {
            double sum(double a, double b);
            double subtract(double a, double b);
            double multiplay(double a, double b);
            double divide(double a, double b);
        }

        private IRpcClient<ICalculator> myRpcClient;

        public Form1()
        {
            InitializeComponent();

            // Get RPC client for declared service interface.
            IRpcFactory anRpcFactory = new RpcFactory();
            myRpcClient = anRpcFactory.CreateClient<ICalculator>();

            // Attach output channel and be able to communicate.
            TcpMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
            IDuplexOutputChannel anOutputChannel = 
                aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8045/");
            myRpcClient.AttachDuplexOutputChannel(anOutputChannel);
        }


        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Stop listening by detaching the input channel.
            myRpcClient.DetachDuplexOutputChannel();
        }

        private void SumButton_Click(object sender, EventArgs e)
        {
            double a = double.Parse(Number1TextBox.Text);
            double b = double.Parse(Number2TextBox.Text);
            ResultLabel.Text = myRpcClient.Proxy.sum(a, b).ToString();
        }
         
        private void SubtractButton_Click(object sender, EventArgs e)
        {
            double a = double.Parse(Number1TextBox.Text);
            double b = double.Parse(Number2TextBox.Text);
            ResultLabel.Text = myRpcClient.Proxy.subtract(a, b).ToString();
        }

        private void MultiplyButton_Click(object sender, EventArgs e)
        {
            double a = double.Parse(Number1TextBox.Text);
            double b = double.Parse(Number2TextBox.Text);
            ResultLabel.Text = myRpcClient.Proxy.multiplay(a, b).ToString();
        }

        private void DivideButton_Click(object sender, EventArgs e)
        {
            double a = double.Parse(Number1TextBox.Text);
            double b = double.Parse(Number2TextBox.Text);
            ResultLabel.Text = myRpcClient.Proxy.divide(a, b).ToString();
        }
    }
}