Java Client类代码示例

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
public static <T> T getRemoteByName(final URI address, final Class<T> clazz, final String name) {

        /* Start QBit client for WebSocket calls. */
        final Client client = ClientBuilder.clientBuilder()
                .setHost(address.getHost())
                .setPort(address.getPort())
                .setUri(address.getPath())
                .build();
        try {
            /* Create a proxy to the service. */
            final T clientProxy = client.createProxy(clazz, name);
            client.start();
            return clientProxy;
        } catch (Exception ex) {
            try {
                client.stop();
            } catch (Exception ex2) {
                //don't log, we are cleaning up.
            }
            /* Wrong place to handle the exception so just rethrow it. */
            throw new IllegalStateException(ex);
        }
    }
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
/** Each client will run this
     *
     * @param numCalls number of times to make calls
     * @param count holds the total count
     */
    private static void runCalls(final int numCalls, final AtomicInteger count) {
        final Client client = clientBuilder().setUri("/").build();

        final TradeServiceAsync tradeService = client.createProxy(TradeServiceAsync.class, "t");

        client.startClient();

        for (int call=0; call < numCalls; call++) {
            tradeService.a(response -> {
                if (response) {
                    count.incrementAndGet();
                    //System.out.println("count " + count.get());
                }
            }, new Trade("IBM", 1));

//            tradeService.t2(new Trade("IBM", 1))
//                    .then(response -> {
//                                if (response) {
//                                    count.incrementAndGet();
//                                }
//                            }
//                    )
//                    .catchError(Throwable::printStackTrace)
//                    .invoke();

            if (call % 100 == 0) {
                if (call > count.get() - 2000) {
                    Sys.sleep(1);
                }
                //flushServiceProxy(tradeService);
            }

        }

        flushServiceProxy(tradeService);
    }
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
private void addEventConnector(final String newHost, final int newPort) {

        if (info) logger.info(Str.sputs("Adding new event connector for",
                eventBusName, "host",
                newHost, "port", newPort));

        /* A client replicator */
        final EventBusReplicationClientBuilder clientReplicatorBuilder = eventBusReplicationClientBuilder();
        clientReplicatorBuilder.setName(this.eventBusName);
        clientReplicatorBuilder.clientBuilder().setPort(newPort).setHost(newHost);
        final Client client = clientReplicatorBuilder.build();
        final EventConnector eventConnector = clientReplicatorBuilder.build(client);
        client.start();
        eventConnectorHub.add(eventConnector);
    }
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
@Override
public Client createClient(final String uri,
                           final HttpClient httpClient,
                           final int requestBatchSize,
                           final BeforeMethodSent beforeMethodSent) {
    return FactorySPI.getClientFactory().create(uri, httpClient, requestBatchSize, beforeMethodSent);
}
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
@Override
public Client create(final String uri,
                     final HttpClient httpClient,
                     final int requestBatchSize,
                     final BeforeMethodSent beforeMethodSent) {
    return new BoonClient(uri, httpClient, requestBatchSize, beforeMethodSent);
}
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
public static void main(final String... args) throws Exception {

        final ClientBuilder clientBuilder = ClientBuilder.clientBuilder();
        final Client client = clientBuilder.setHost("localhost")
                .setPort(8080).setUri("/echo")
                .build().startClient();

        final EchoAsync echoClient = client.createProxy(EchoAsync.class, "echo");


        for (int index = 0; index < 100; index++) {
            echoClient.echo(s -> System.out.println(s), "index" + index);

        }

        ServiceProxyUtils.flushServiceProxy(echoClient);

    }
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
public static void main(final String... args) throws Exception {

        final ClientBuilder clientBuilder = ClientBuilder.clientBuilder();
        final Client client = clientBuilder.setServiceDiscovery(new ServiceDiscoveryMock(), "echo")
                .setUri("/echo").setProtocolBatchSize(20).build().startClient();

        final EchoAsync echoClient = client.createProxy(EchoAsync.class, "echo");


        for (int index = 0; index < 100000; index++) {
            echoClient.echo(s -> System.out.println(s), "index" + index);

            if (index % 20 == 0) {
                ServiceProxyUtils.flushServiceProxy(echoClient);
            }

        }

        ServiceProxyUtils.flushServiceProxy(echoClient);

    }
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
@Test //Works
public void testWithClient() {


    int port = PortUtils.findOpenPortStartAt(9999);
    final ServiceEndpointServer serviceEndpointServer =
            EndpointServerBuilder.endpointServerBuilder().setPort(port)
                    .addService("foo", new FeedServiceImpl()).build().startServerAndWait();


    final Client client = ClientBuilder.clientBuilder().setPort(port).build().startClient();

    final FeedService feedService = client.createProxy(FeedService.class, "foo");


    final List<FeedMeta> feedMetas = feedService.listFeeds().blockingGet(Duration.ofSeconds(30));


    assertNotNull(feedMetas);
    assertEquals(1, feedMetas.size());

    assertEquals("Hello", feedMetas.get(0).name);

    serviceEndpointServer.stop();
    client.stop();
}
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
default Client createClient(String uri,
                            HttpClient httpClient,
                            int requestBatchSize,
                            BeforeMethodSent beforeMethodSent) {
    throw new UnsupportedOperationException();
}
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
Client create(String uri,
HttpClient httpClient,
int requestBatchSize,
final BeforeMethodSent beforeMethodSent);
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
@Test
public void testDisconnect() {
    final int port = PortUtils.findOpenPortStartAt(7777);

    final ServiceEndpointServer serviceEndpointServer = EndpointServerBuilder.endpointServerBuilder()
            .setPort(port).setHost("localhost")
            .addService(new EmployeeServiceImpl()).build().startServerAndWait();

    final Client client = ClientBuilder.clientBuilder().setPort(port).setHost("localhost").build().startClient();

    final EmployeeServiceClient employeeService = client.createProxy(EmployeeServiceClient.class, "employeeserviceimpl");

    Promise<Employee> promise = Promises.blockingPromise();

    employeeService.addEmployee(new Employee("rick")).asHandler().invokeWithPromise(promise.asHandler());

    ServiceProxyUtils.flushServiceProxy(employeeService);
    assertTrue(promise.asHandler().success());

    serviceEndpointServer.stop();

    promise = Promises.blockingPromise();

    employeeService.addEmployee(new Employee("rick")).asHandler().invokeWithPromise(promise.asHandler());

    assertTrue(promise.asHandler().failure());

    assertTrue(promise.asHandler().cause() instanceof ConnectException);

    client.stop();

}
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
@Test
public void testSendGenericList() {

    final int port = PortUtils.findOpenPortStartAt(7777);

    final ServiceEndpointServer serviceEndpointServer = EndpointServerBuilder.endpointServerBuilder()
            .setPort(port).setHost("localhost")
            .addService(new EmployeeServiceImpl()).build().startServerAndWait();

    final Client client = ClientBuilder.clientBuilder().setPort(port).setHost("localhost").build().startClient();

    final EmployeeServiceClient employeeService = client.createProxy(EmployeeServiceClient.class, "employeeserviceimpl");

    Promise<Boolean> promise = Promises.blockingPromise();

    employeeService.addEmployees(Arrays.asList(new Employee("rick"))).asHandler().invokeWithPromise(promise.asHandler());

    ServiceProxyUtils.flushServiceProxy(employeeService);

    boolean success = promise.asHandler().success();

    if (!success) {
        promise.asHandler().cause().printStackTrace();
    }
    assertTrue(success);


    serviceEndpointServer.stop();
    client.stop();

}
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
@Test
public void test() throws Exception {


    final int port = PortUtils.findOpenPortStartAt(7777);
    final ServiceEndpointServer serviceEndpointServer = EndpointServerBuilder.endpointServerBuilder()
            .setPort(port).setHost("localhost")
            .addService(new EmployeeServiceImpl()).build().startServerAndWait();

    final Client client = ClientBuilder.clientBuilder().setPort(port).setHost("localhost").build().startClient();

    final EmployeeService employeeService = client.createProxy(EmployeeService.class, "employeeserviceimpl");

    ServiceProxyUtils.flushServiceProxy(employeeService);


    AtomicLong counter = new AtomicLong();
    final CountDownLatch latch = new CountDownLatch(20);

    for (int index = 0; index < 20; index++) {
        final AtomicReference<Employee> ref = new AtomicReference<>();
        employeeService.addEmployee(employee -> {
            ref.set(employee);
            System.out.println(ref.get());
            counter.incrementAndGet();
            latch.countDown();
        }, new Employee("rick"));

    }


    latch.await(2, TimeUnit.SECONDS);
    assertEquals(20, counter.get());


    serviceEndpointServer.stop();
}
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
public static void main(String... args) throws Exception {

        Client client = new ClientBuilder().setPort(9998)
                .setAutoFlush(true).setFlushInterval(50)
                .setProtocolBatchSize(50).build();

        PingService pingService = client.createProxy(PingService.class, "ping");

        client.start();

        pingService.ping(s -> puts("FROM SERVER", s));
    }
 

import io.advantageous.qbit.client.Client; //导入依赖的package包/类
public static void main(String... args) {

        String host = "localhost";

        int port = 8080;


        /* Create a client object.
        * A client object connects to a ServiceEndpointServer so
        * you can invoke a service over WebSocket.
        */
        final Client client = new ClientBuilder()
                .setPort(port).setHost(host).setPollTime(10)
                .setAutoFlush(true).setFlushInterval(50)
                .setRequestBatchSize(50)
                .setProtocolBatchSize(50).build();

        client.start();

        final TodoServiceClientInterface todoService =
                client.createProxy(TodoServiceClientInterface.class, "todoService");



        todoService.add(new TodoItem("Buy Milk"));
        todoService.add(new TodoItem("Buy Hot dogs"));
        todoService.list(todoItems -> { //LAMBDA EXPRESSION Java 8

            for (TodoItem item : todoItems) {
                System.out.println("TODO ITEM " +
                        item.getDescription() + " " +
                        item.getName() + " " +
                        item.getDue());
            }
        });


        Sys.sleep(1000);


    }