Java ClusterClientSettings类代码示例

import akka.cluster.client.ClusterClientSettings; //导入依赖的package包/类
public static ActorSystem startWorkersWithExecutors(AgentConfig agent) {
    Config conf = ConfigFactory.parseString("akka.cluster.roles=[" + agent.getActor().getRole() + "]")
            .withFallback(ConfigFactory.parseString("akka.remote.netty.tcp.port=" + agent.getActor().getPort()))
            .withFallback(ConfigFactory.parseString("akka.remote.netty.tcp.hostname=" + HostUtils.lookupIp()))
            .withFallback(ConfigFactory.load("application"));

    ActorSystem system = ActorSystem.create(Constants.PerformanceSystem, conf);

    Set<ActorPath> initialContacts = new HashSet<>(agent.getContactPoint()
                .map(p->ActorPaths.fromString(p))
                .collect(Collectors.toList()));

    ClusterClientSettings settings =  ClusterClientSettings.create(system).withInitialContacts(initialContacts);
    final ActorRef clusterClient = system.actorOf(ClusterClient.props(settings), "clusterClient");

    IntStream.range(1,agent.getActor().getNumberOfActors()+1).forEach(i->
        system.actorOf(Worker.props(clusterClient,
                        createWorkExecutor(agent),
                        agent.getActor().getRole()),
                        agent.getActor().getRole()+i)
    );
    return system;

}
 

import akka.cluster.client.ClusterClientSettings; //导入依赖的package包/类
public static ActorSystem startCommandClient(ClientConfig clientConfig) {
    Config conf = ConfigFactory.parseString("akka.cluster.roles=[" + clientConfig.getRole() + "]")
            .withFallback(ConfigFactory.parseString("akka.remote.netty.tcp.port=" + clientConfig.getPort()))
            .withFallback(ConfigFactory.parseString("akka.remote.netty.tcp.hostname=" + HostUtils.lookupIp()))
            .withFallback(ConfigFactory.load("application"));

    ActorSystem system = ActorSystem.create(Constants.PerformanceSystem, conf);

    Set<ActorPath> initialContacts = new HashSet<>(clientConfig.getContactPoint()
                .map(p->ActorPaths.fromString(p))
                .collect(Collectors.toList()));

    ClusterClientSettings settings =  ClusterClientSettings.create(system).withInitialContacts(initialContacts);
    final ActorRef clusterClient = system.actorOf(ClusterClient.props(settings), "clusterClient");

    system.actorOf(CommandClientActor.props(clusterClient, clientConfig), clientConfig.getRole() );

    return system;

}
 

import akka.cluster.client.ClusterClientSettings; //导入依赖的package包/类
public static void startWorker(int port) {
  Config conf = ConfigFactory.parseString("akka.remote.netty.tcp.port=" + port).
      withFallback(ConfigFactory.load("worker"));

  ActorSystem system = ActorSystem.create("WorkerSystem", conf);

  ActorRef clusterClient = system.actorOf(
      ClusterClient.props(ClusterClientSettings.create(system)),
      "clusterClient");
  system.actorOf(Worker.props(clusterClient, Props.create(WorkExecutor.class)), "worker");
}
 

import akka.cluster.client.ClusterClientSettings; //导入依赖的package包/类
@Test
public void testWorkers() throws Exception {
  new JavaTestKit(system) {{
    TestProbe clusterProbe = new TestProbe(system);
    Cluster.get(system).subscribe(clusterProbe.ref(), ClusterEvent.MemberUp.class);
    clusterProbe.expectMsgClass(ClusterEvent.CurrentClusterState.class);

    Address clusterAddress = Cluster.get(system).selfAddress();
    Cluster.get(system).join(clusterAddress);
    clusterProbe.expectMsgClass(ClusterEvent.MemberUp.class);

    system.actorOf(
        ClusterSingletonManager.props(
            Master.props(workTimeout),
            PoisonPill.getInstance(),
            ClusterSingletonManagerSettings.create(system).withRole("backend")
        ),
        "master");

    Set<ActorPath> initialContacts = new HashSet<>();
    initialContacts.add(ActorPaths.fromString(clusterAddress + "/system/receptionist"));

    ActorRef clusterClient = system.actorOf(
      ClusterClient.props(ClusterClientSettings.create(system).withInitialContacts(initialContacts)),
      "clusterClient");


    for (int n = 1; n <= 3; n += 1) {
      system.actorOf(Worker.props(clusterClient,
        Props.create(WorkExecutor.class), registerInterval), "worker-" + n);
    }

    ActorRef flakyWorker = system.actorOf(Worker.props(clusterClient,
      Props.create(FlakyWorkExecutor.class), registerInterval), "flaky-worker");

    final ActorRef frontend = system.actorOf(Props.create(Frontend.class), "frontend");

    final JavaTestKit results = new JavaTestKit(system);

    DistributedPubSub.get(system).mediator().tell(
      new DistributedPubSubMediator.Subscribe(Master.ResultsTopic, results.getRef()),
      getRef());
    expectMsgClass(DistributedPubSubMediator.SubscribeAck.class);




    // might take a while for things to get connected
    new AwaitAssert(duration("10 seconds")) {
      protected void check() {
        frontend.tell(new Master.Work("1", 1), getRef());
        expectMsgEquals(Frontend.Ok.getInstance());
      }
    };

    assertEquals(results.expectMsgClass(Master.WorkResult.class).workId, "1");

    for (int n = 2; n <= 100; n += 1) {
      frontend.tell(new Master.Work(Integer.toString(n), n), getRef());
      expectMsgEquals(Frontend.Ok.getInstance());
    }

    results.new Within(duration("10 seconds")) {
      public void run() {
        Object[] messages = results.receiveN(99);
        SortedSet<Integer> set = new TreeSet<Integer>();
        for (Object m: messages) {
          set.add(Integer.parseInt(((Master.WorkResult) m).workId));
        }
        // nothing lost, and no duplicates
        Iterator<Integer> iterator = set.iterator();
        for (int n = 2; n <= 100; n += 1) {
          assertEquals(n, iterator.next().intValue());
        }
      }
    };
  }};
}
 

import akka.cluster.client.ClusterClientSettings; //导入依赖的package包/类
/**
 * Create ClientActor for each region.
 */
private void createClientActors( ActorSystem system ) {

    for ( String region : getSeedsByRegion().keySet() ) {

        if ( currentRegion.equals( region )) {

            logger.info( "Creating clientActor for region [{}]", region );

            // Each clientActor needs to know path to ClusterSingletonProxy and region
            clientActor = system.actorOf(
                Props.create( ClientActor.class, routersByMessageType ), "clientActor" );

            ClusterClientReceptionist.get(system).registerService( clientActor );

        } else {

            logger.info( "Creating clusterClient for region [{}]", region );

            Set<ActorPath> seedPaths = new HashSet<>(20);
            for ( String seed : getSeedsByRegion().get( region ) ) {
                seedPaths.add( ActorPaths.fromString( seed + "/system/receptionist") );
            }

            ActorRef clusterClient = system.actorOf( ClusterClient.props(
                ClusterClientSettings.create(system).withInitialContacts( seedPaths )), "client");

            clusterClientsByRegion.put( region, clusterClient );
        }
    }
}