Java UntypedActor类代码示例

import akka.actor.UntypedActor; //导入依赖的package包/类
/** implementation du service Install */   
@SuppressWarnings("serial")
public void install(String nomLogiciel, String listImages) {
	
	if (nomLogiciel.equals("frascati")) this.logiciel= this.logicielFrascati;
	if (nomLogiciel.equals("nodejs")) this.logiciel= this.logicielNodejs;
	
	this.imageVirtuels.clear();
	
	String tab[]= listImages.split(" ");
	for (int i = 0; i < tab.length; i++) {
		this.imageVirtuels.add(new VirtuelImage(tab[i],tab[i],tab[i]));
	}
	
	// creation de l'actor ControllerSoftwareSupervisor
	controllerSoftwareSupervisor = systemSoftware.actorOf(new Props(new UntypedActorFactory() {
		public UntypedActor create() {
		 return new ControllerSoftwareSupervisor(imageVirtuels,logiciel,sh,new Props(WorkerInstall.class),listener);
		}
	}), "ControllerVMSupervisor");		
	 
	// demarrer le déploiement
	controllerSoftwareSupervisor.tell(new MessageExecuteService());	
	
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
/** implementation du service Create container */   
@SuppressWarnings("serial")
public void createContainer(String listImages) {

		System.out.println("nom des container à créer "+listImages);
               	
this.imageVirtuels.clear();
			String tab[]= listImages.split(" ");
			for (int i = 0; i < tab.length; i++) {
				this.imageVirtuels.add(new VirtuelImage(tab[i],tab[i],tab[i]));	
			}
							
	// creation de l'actor ControllerVMSupervisor
	controllerVmSupervisor = systemVm.actorOf(new Props(new UntypedActorFactory() {
		public UntypedActor create() {
		 return new ControllerVMSupervisor(imageVirtuels,pathFabFile,sh,new Props(WorkerCreateContainer.class),listener);
		}
	}), "ControllerVMSupervisor");		
	 
	// démarrer l'exécution
	controllerVmSupervisor.tell(new MessageExecuteService());	
	
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
/** implementation du service Create container */   
@SuppressWarnings("serial")
public void startContainer(String listImages) {
this.imageVirtuels.clear();
		String tab[]= listImages.split(" ");
		for (int i = 0; i < tab.length; i++) {
			this.imageVirtuels.add(new VirtuelImage(tab[i],tab[i],tab[i]));	
		}
				
	// creation de l'actor ControllerVMSupervisor
	controllerVmSupervisor = systemVm.actorOf(new Props(new UntypedActorFactory() {
		public UntypedActor create() {
		 return new ControllerVMSupervisor(imageVirtuels,pathFabFile,sh,new Props(WorkerStartContainer.class),listener);
		}
	}), "ControllerVMSupervisor");		
	 
	// démarrer l'exécution
	controllerVmSupervisor.tell(new MessageExecuteService());	
	
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
/** implementation du service Create container */   
	@SuppressWarnings("serial")
	public void stopContainer(String listImages) {
					
this.imageVirtuels.clear();
		String tab[]= listImages.split(" ");
		for (int i = 0; i < tab.length; i++) {
			this.imageVirtuels.add(new VirtuelImage(tab[i],tab[i],tab[i]));	
		}
		// creation de l'actor ControllerVMSupervisor
		controllerVmSupervisor = systemVm.actorOf(new Props(new UntypedActorFactory() {
			public UntypedActor create() {
			 return new ControllerVMSupervisor(imageVirtuels,pathFabFile,sh,new Props(WorkerStopContainer.class),listener);
			}
		}), "ControllerVMSupervisor");		
		 
		// démarrer l'exécution
		controllerVmSupervisor.tell(new MessageExecuteService());	
		
	}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
/**
 * Attempts to register the subscriber to the specified channel.
 *
 * @return the temporary actor that delegates the event to given handler
 */
public <T> ActorRef subscribeEvent(final Handler<T> handler, final Class<T> channel) {
    ActorRef ref = system.actorOf(new Props().withCreator(new Creator<Actor>() {
        @Override
        public Actor create() throws Exception {
            return new UntypedActor() {
                @Override
                public void onReceive(Object message) throws Exception {
                    if (message != null && message.getClass().equals(channel)) {
                        handler.handle(channel.cast(message));
                    } else {
                        unhandled(message);
                    }
                }
            };
        }
    }));

    eventStream().subscribe(ref, channel);
    return ref;
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
@Test
public void detach() throws Exception {
    ActorModel<Integer> model = new ActorModel<Integer>() {
        @Override
        protected ActorRef newActor() {
            return system().actorOf(Props.apply(new Creator<Actor>() {
                @Override
                public Actor create() throws Exception {
                    return new UntypedActor() {
                        @Override
                        public void onReceive(Object message) throws Exception {
                            unhandled(message);
                        }
                    };
                }
            }));
        }
    };

    model.detach();
    Thread.sleep(100);

    assertThat(model.getObject(), is(nullValue()));
    assertThat(model.getActorRef().isTerminated(), is(true));
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
private static void RegisterActors(Binder binder) {
	Logger.debug("Actor Scanner Started...");
	final Map<String, ActorHolder> map = new HashMap<>();		
	final ConfigurationBuilder configBuilder = build();
	final Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner()));
	final Set<Class<? extends UntypedActor>> actors = reflections.getSubTypesOf(UntypedActor.class);
       final Set<Class<? extends AbstractActor>> abstractActors = reflections.getSubTypesOf(AbstractActor.class);
       loopOnActors(map, actors);
       loopOnAbstractActors(map, abstractActors);
       if(!map.isEmpty()) Logger.debug("Registering actors: ");
	for(final String key : map.keySet()) {
		final ActorHolder actorHolder = map.get(key);
		final Class<? extends Actor> actor = actorHolder.getActor();
		if(actorHolder.isSingleton()) {
			Logger.debug("Binding class " + actor.getSimpleName() + " to name: " + key + " Singleton Scoped.");
			binder.bind(ActorRef.class).annotatedWith(Names.named(key)).toProvider(new ActorRefProvider(actor, key, true)).in(Singleton.class);
		} else {
			Logger.debug("Binding class " + actor.getSimpleName() + " to name: " + key + " Request Scoped.");
			binder.bind(ActorRef.class).annotatedWith(Names.named(key)).toProvider(new ActorRefProvider(actor, key, false));
			PropsContext.put(key, actorHolder);
		}
	}
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
private static void loopOnActors(Map<String, ActorHolder> map, Set<Class<? extends UntypedActor>> actors) {
    for(final Class<? extends Actor> actor : actors) {
        if(ignore.contains(actor.getSimpleName())) continue;
        final String named = getNamed(actor);
        final boolean isSingleton = isSingleton(actor);
        final ActorHolder actorHolder = new ActorHolder(actor, isSingleton);
        if(named != null) {
            map.put(named, actorHolder);
        } else {
            if(map.containsKey(actor.getSimpleName())){
                map.put(actor.getName(), actorHolder);
                final ActorHolder tempHolder = map.remove(actor.getSimpleName());
                map.put(tempHolder.getActor().getName(), tempHolder);
            }
            else map.put(actor.getSimpleName(), actorHolder);
        }
    }
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
@SuppressWarnings("serial")
public void remoteActorRefDemo() {
	log.info("Creating a reference to remote actor");
	// creating a reference to the remote ServerActor
	// by passing the complete remote actor path
	remoteActor = system
			.actorFor("akka://[email protected]:2552/user/serverActor");

	log.info("ServerActor with hashcode #" + remoteActor.hashCode());
	
	// create a local actor and pass the reference of the remote actor
	actor = system.actorOf(new Props(new UntypedActorFactory() {
		public UntypedActor create() {
			return new ClientActor(remoteActor);
		}
	}));
	// send a message to the local client actor
	actor.tell("Start-RemoteActorRef");
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
@SuppressWarnings("serial")
public void remoteActorCreationDemo1() {
	log.info("Creating a actor using remote deployment mechanism");

	// create the address object that points to the remote server
	Address addr = new Address("akka", "ServerSys", "127.0.0.1", 2552);

	// creating the ServerActor on the specified remote server
	final ActorRef serverActor = system.actorOf(new Props(ServerActor.class)
			.withDeploy(new Deploy(new RemoteScope(addr))));

	// create a local actor and pass the reference of the remote actor
	actor = system.actorOf(new Props(new UntypedActorFactory() {
		public UntypedActor create() {
			return new ClientActor(serverActor);
		}
	}));
	// send a message to the local client actor
	actor.tell("Start-RemoteActorCreationDemo1");
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
@SuppressWarnings("serial")
public void remoteActorCreationDemo2() {
	log.info("Creating a actor with remote deployment");

	// alternate way to create the address object that points to the remote
	// server
	Address addr = AddressFromURIString
			.parse("akka://[email protected]:2552");

	// creating the ServerActor on the specified remote server
	final ActorRef serverActor = system.actorOf(new Props(ServerActor.class)
			.withDeploy(new Deploy(new RemoteScope(addr))));

	// create a local actor and pass the reference of the remote actor
	actor = system.actorOf(new Props(new UntypedActorFactory() {
		public UntypedActor create() {
			return new ClientActor(serverActor);
		}
	}));
	// send a message to the local client actor
	actor.tell("Start-RemoteActorCreationDemo2");
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
@SuppressWarnings("serial")
public void remoteActorCreationDemo3() {
	log.info("Creating a actor with remote deployment");

	// creating the ServerActor on the specified remote server
	final ActorRef serverActor = system.actorOf(new Props(ServerActor.class),"remoteServerActor");

	// create a local actor and pass the reference of the remote actor
	actor = system.actorOf(new Props(new UntypedActorFactory() {
		public UntypedActor create() {
			return new ClientActor(serverActor);
		}
	}));
	// send a message to the local client actor
	actor.tell("Start-RemoteActorCreationDemo3");
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
@Test
public void testFilteringActor() {
	ActorRef filteringActorRef = _system.actorOf(new Props(
			new UntypedActorFactory() {
				public UntypedActor create() {
					return new FilteringActor(testActor());
				}
			}));
	// pass the reference to implicit sender testActor() otherwise
	// message end up in dead mailbox
	// first test
	filteringActorRef.tell("test message", super.testActor());
	expectMsg("test message");
	// second test
	filteringActorRef.tell(1, super.testActor());
	expectNoMsg();
}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
public ApplicationManagerSystem() {

		final int no_of_workers = 10;

		system = ActorSystem.create("LoadGeneratorApp");

		final ActorRef appManager = system.actorOf(
				new Props(new UntypedActorFactory() {
					public UntypedActor create() {
						return new JobControllerActor(no_of_msgs);
					}
				}), "jobController");

		router = system.actorOf(new Props(new UntypedActorFactory() {
			public UntypedActor create() {
				return new WorkerActor(appManager);
			}
		}).withRouter(new RoundRobinRouter(no_of_workers)));
	}
 

import akka.actor.UntypedActor; //导入依赖的package包/类
private static RaftActorContextImpl newFollowerContext(String id, TestActorRef<? extends UntypedActor> actor) {
    DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
    configParams.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
    configParams.setElectionTimeoutFactor(100000);
    NonPersistentDataProvider noPersistence = new NonPersistentDataProvider(Runnable::run);
    ElectionTermImpl termInfo = new ElectionTermImpl(noPersistence, id, LOG);
    termInfo.update(1, LEADER_ID);
    return new RaftActorContextImpl(actor, actor.underlyingActor().getContext(),
            id, termInfo, -1, -1, ImmutableMap.of(LEADER_ID, ""), configParams,
            noPersistence, applyState -> actor.tell(applyState, actor), LOG);
}