jsonrpc4j

Use ProxyUtil.createCompositeServiceProxy to merge multiple service interfaces into a single proxy object. This allows a single JSON-RPC endpoint to expose methods from various services. You can then pass this composite proxy to a JsonRpcServer to expose all methods at one location.

UserverService userService = ...;
ContentService contentService = ...;
BlackJackService blackJackService = ...;

Object compositeService = ProxyUtil.createCompositeServiceProxy(
    this.getClass().getClassLoader(),
    new Object[] { userService, contentService, blackJackService},
    new Class<?>[] { UserService.class, ContentService.class, BlackJackService.class},
    true);

// Use the composite service
User user = ((UserverService)compositeService).createUser(...);

// Expose all via one server
JsonRpcServer jsonRpcServer = new JsonRpcServer(compositeService);

Add the jsonrpc4j dependency to your project to use JSON-RPC features in Java. The library uses Jackson for JSON serialization/deserialization. If you are already using Spring, most dependencies are likely already present, except potentially Jackson.

<!-- Maven -->
<dependency>
    <groupId>com.github.briandilley.jsonrpc4j</groupId>
    <artifactId>jsonrpc4j</artifactId>
    <version>1.7</version>
</dependency>

// Gradle
implementation('com.github.briandilley.jsonrpc4j:jsonrpc4j:1.7')

The StreamServer class provides a straightforward way to run a JSON-RPC server over raw Sockets. It is non-blocking on start and blocks on stop until shutdown is complete.

// 1. Create the JsonRpcServer
JsonRpcServer jsonRpcServer = new JsonRpcServer(...);

// 2. Create the StreamServer
int maxThreads = 50;
int port = 1420;
InetAddress bindAddress = InetAddress.getByName("...");
StreamServer streamServer = new StreamServer(
    jsonRpcServer, maxThreads, port, bindAddress);

// 3. Start (non-blocking)
streamServer.start();

// 4. Stop (blocking)
streamServer.stop();

To communicate with a JSON-RPC service without using the Spring Framework, instantiate a JsonRpcHttpClient with the service URL. You can invoke methods directly by passing the method name, an array of arguments, and the expected return class.

JsonRpcHttpClient client = new JsonRpcHttpClient(
    new URL("http://example.com/UserService.json"));

User user = client.invoke("createUser", new Object[] { "bob", "the builder" }, User.class);

You can host a JSON-RPC server without Spring by instantiating JsonRpcServer with your service implementation and its interface class. To handle requests in a web environment, call the handle(req, resp) method within a servlet's doPost method.

// Create the server
JsonRpcServer server = new JsonRpcServer(userService, UserService.class);

// Example usage in a Servlet
class UserServiceServlet extends HttpServlet {
    private UserService userService;
    private JsonRpcServer jsonRpcServer;

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        jsonRpcServer.handle(req, resp);
    }

    public void init(ServletConfig config) {
        this.jsonRpcServer = new JsonRpcServer(this.userService, UserService.class);
    }
}

To consume a JSON-RPC service from a Spring application, use the JsonProxyFactoryBean. This creates a dynamic proxy of your service interface that transparently makes remote calls.

<bean class="com.googlecode.jsonrpc4j.spring.JsonProxyFactoryBean">
    <property name="serviceUrl" value="http://example.com/UserService.json"/>
    <property name="serviceInterface" value="com.mycompany.UserService"/>
</bean>

Instead of manual invocation, you can use ProxyUtil.createClientProxy to create a dynamic proxy of your service interface. This allows you to call methods directly on the interface as if it were a local object.

JsonRpcHttpClient client = new JsonRpcHttpClient(
    new URL("http://example.com/UserService.json"));

UserService userService = ProxyUtil.createClientProxy(
    getClass().getClassLoader(),
    UserService.class,
    client);

User user = userService.createUser("bob", "the builder");

By default, JSON-RPC may use indexed parameters. To use named parameters in your JSON requests, annotate the parameters in your service interface with @JsonRpcParam.

package com.mycompany;

public interface UserService {
    User createUser(@JsonRpcParam(value="theUserName") String userName, @JsonRpcParam(value="thePassword") String password);
}

Use @JsonRpcFixedParam to inject constant values into a service method that the client does not need to provide. You can use @JsonRpcFixedParams to provide a collection of multiple fixed parameters.

@JsonRpcService("/jsonrpc")
public interface LibraryService {
    @JsonRpcMethod("VideoLibrary.GetTVShows")
    @JsonRpcFixedParam(name = "status", value = "published")
    List<TVShow> fetchTVShows(@JsonRpcParam(value="properties") final List<String> properties);
}

JSON Request:

{
    "jsonrpc":"2.0", 
    "method": "VideoLibrary.GetTVShows", 
    "params": { 
        "status": "published", 
        "properties": ["title"] 
    }, 
    "id":1
}