Приложение Java RPC с активной библиотекой RPC

Что такое активный RPC?

Active RPC – это легкая и удобная библиотека Java для разработки высоконагруженных распределенных приложений и решений, подобных Memcached. Он представляет совершенно альтернативный подход к реализации микросервисов и устраняет накладные расходы, связанные с использованием протокола HTTP с кодировкой JSON или XML.

Active RPC работает на одном из самых быстрых в мире сериализаторов JVM Active Сериализатор , работает по протоколу TCP и имеет пользовательский высокопроизводительный протокол двоичной потоковой передачи. Он имеет высоко оптимизированные гибкие серверные и клиентские реализации, а также предопределенные облачные стратегии. С помощью этих технологий вы можете удобно создавать даже сложные масштабируемые решения, такие как высокопроизводительные микросервисы или серверы, подобные Memcached.

Основной пример

public class RpcExample extends Launcher {
    private static final int SERVICE_PORT = 34765;

    @Inject
    private RpcClient client;

    @Inject
    private RpcServer server;

    @Inject
    private Eventloop eventloop;

    @Provides
    Eventloop eventloop() {
        return Eventloop.create();
    }

    @Provides
    RpcServer rpcServer(Eventloop eventloop) {
        return RpcServer.create(eventloop)
                .withMessageTypes(String.class)
                .withHandler(String.class,
                        request -> Promise.of("Hello " + request))
                .withListenPort(SERVICE_PORT);
    }

    @Provides
    RpcClient rpcClient(Eventloop eventloop) {
        return RpcClient.create(eventloop)
                .withMessageTypes(String.class)
                .withStrategy(server(new InetSocketAddress(SERVICE_PORT)));
    }

    @ProvidesIntoSet
    Initializer configureServiceGraph() {
        // add logical dependency so that service graph starts client only after it started the server
        return settings -> settings.addDependency(Key.of(RpcClient.class), Key.of(RpcServer.class));
    }

    @Override
    protected Module getModule() {
        return ServiceGraphModule.create();
    }

    @Override
    protected void run() throws ExecutionException, InterruptedException {
        CompletableFuture

Пример Rpc класс расширяет активный Launcher чтобы помочь нам управлять ведением журнала и всем жизненным циклом приложения.

Далее мы используем библиотеку внедрения зависимостей Активная инъекция для обеспечения Сервер Rpc и Клиент Rpc с соответствующими конфигурациями и необходимыми зависимостями. Rpc-клиент отправляет запросы с сильным сообщением на указанный сервер в соответствии с предоставленной стратегией RPC (в данном случае получение одного RPC-сервиса). Для Rpc-Сервера мы определяем тип сообщений для продолжения, соответствующий Обработчик запросов Rpc

Поскольку мы расширяем Launcher , мы также переопределим 2 метода: getModule для предоставления Модуля графа обслуживания и запуска для описания основной логики примера.

Наконец, мы определяем метод main , который запустит наш пример.

Вы можете найти примеры источников на GitHub .

Комбинирование стратегий

В предыдущем примере мы использовали одну из простейших стратегий, которая просто работает с одним предоставленным портом. Тем не менее, как уже упоминалось выше, Активный RPC включает в себя заранее определенные стратегии, которые вы можете просто использовать и комбинировать.

Например, давайте объединим Циклическую и Первую доступную стратегии. Сначала мы создаем 4 соединения, не помещая соединение 3 в пул. Затем мы начинаем отправлять 20 запросов. В результате все запросы будут равномерно распределены между соединением 1 (так как он всегда доступен первым) и соединение 4 ((поскольку соединение 3 недоступно для пула):

pool.put(ADDRESS_1, connection1);
pool.put(ADDRESS_2, connection2);
// we don't put connection3
pool.put(ADDRESS_4, connection4);
int iterations = 20;
RpcStrategy strategy = roundRobin(
        firstAvailable(servers(ADDRESS_1, ADDRESS_2)),
        firstAvailable(servers(ADDRESS_3, ADDRESS_4)));

RpcSender sender = strategy.createSender(pool);
for (int i = 0; i < iterations; i++) {
    sender.sendRequest(new Object(), 50, assertNoCalls());
}

Давайте рассмотрим еще один пример, Введите Стратегию отправки . Эта стратегия просто распределяет запросы между сегментами в соответствии с типом запроса. В примере все строковые запросы отправляются на первый сегмент, который имеет Первый допустимый результат стратегию для серверов. Запросы со всеми остальными типами отправляются на второй общий доступ с Первой доступной стратегией . В результате соединение 1 и соединение 2 будет обрабатывать 35 запросов, соединение 3 – 25 запросы, в то время как соединение 4 и соединение 5 - 0 запросы как соединение 3 всегда Первый доступный

pool.put(ADDRESS_1, connection1);
pool.put(ADDRESS_2, connection2);
pool.put(ADDRESS_3, connection3);
pool.put(ADDRESS_4, connection4);
pool.put(ADDRESS_5, connection5);
int timeout = 50;
int iterationsPerDataStub = 25;
int iterationsPerDataStubWithKey = 35;
RpcSender sender;
RpcStrategy strategy = typeDispatching()
        .on(String.class,
                firstValidResult(servers(ADDRESS_1, ADDRESS_2)))
        .onDefault(
                firstAvailable(servers(ADDRESS_3, ADDRESS_4, ADDRESS_5)));

sender = strategy.createSender(pool);
for (int i = 0; i < iterationsPerDataStub; i++) {
    sender.sendRequest(new Object(), timeout, assertNoCalls());
}
for (int i = 0; i < iterationsPerDataStubWithKey; i++) {
    sender.sendRequest("request", timeout, assertNoCalls());
}

В следующем уроке мы создадим решение, подобное Memcached, которое может обрабатывать до 10 миллионов запросов в секунду на одном ядре, используя ActiveRPC .

Оригинал: “https://dev.to/activej/java-rpc-application-with-activerpc-library-2j6f”