Akka 【二】Create Actor

最新推荐文章于 2023-04-12 11:47:11 发布
最新推荐文章于 2023-04-12 11:47:11 发布
阅读量2.6k 收藏 1
点赞数
分类专栏： Akka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xlnjulp/article/details/37698213
版权

在介绍如何创建actor之前，先来看一个类Props。Props是一个配置类，用于指定创建actor的参数等。以下是Props的几个典型应用，

Props


1）直接传入所需要创建的actor对应的类

import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.actor.UntypedActor;

public class CreateTest {
	enum MSG {
		HI, OK
	}

	static class Actor1 extends UntypedActor {

		@Override
		public void onReceive(Object message) throws Exception {
			// TODO Auto-generated method stub
			if (message instanceof MSG) {
				if (message.equals(MSG.OK)) {
					System.out.println("i receive ok");
				} else {
					unhandled(message);
				}
			} else {
				unhandled(message);
			}

		}

	}

	static class Actor2 extends UntypedActor {

		@Override
		public void onReceive(Object message) throws Exception {
			if (message instanceof MSG) {
				if (message.equals(MSG.HI)) {
					System.out.println("i receive hi");
					getSender().tell(MSG.OK, getSelf());
				} else {
					unhandled(message);
				}
			} else {
				unhandled(message);
			}
		}

	}
	
	public static void communication(){
		
		// 这里直接传入所需要创建的Actor对应的类
		Props props1 = Props.create(Actor1.class);
		Props props2 = Props.create(Actor2.class);
		
		// 使用Props创建Actor
		final ActorSystem system = ActorSystem.create("MySystem");
		final ActorRef actor1 = system.actorOf(props1, "Actor1");
		final ActorRef actor2 = system.actorOf(props2, "Actor2");
		actor2.tell(MSG.HI, actor1);
		
		system.stop(actor1);
		system.stop(actor2);
		system.shutdown();
	}

	public static void main(String[] args) {
		communication();
	}
}



在这种情况下，创建actor的时候会调用默认的构造函数。


2）直接传入所需要创建的actor对应的类，以及构造函数的参数

import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.actor.UntypedActor;

public class CreateTest {
	enum MSG {
		HI, OK
	}

	static class Actor1 extends UntypedActor {
		String name;
		int index;
		
		Actor1(String name, int index){
			this.name = name;
			this.index = index;
		}
		
		@Override
		public void onReceive(Object message) throws Exception {
			System.out.println(name + "_" + index + " receive message");
			if (message instanceof MSG) {
				if (message.equals(MSG.OK)) {
					System.out.println("i receive ok");
				} else {
					unhandled(message);
				}
			} else {
				unhandled(message);
			}

		}

	}

	static class Actor2 extends UntypedActor {
		String name;
		int index;
		
		Actor2(String name, int index){
			this.name = name;
			this.index = index;
		}
		
		@Override
		public void onReceive(Object message) throws Exception {
			System.out.println(name + "_" + index + " receive message");
			if (message instanceof MSG) {
				if (message.equals(MSG.HI)) {
					System.out.println("i receive hi");
					getSender().tell(MSG.OK, getSelf());
				} else {
					unhandled(message);
				}
			} else {
				unhandled(message);
			}
		}

	}
	
	public static void communication(){
		
		// 这里直接传入所需要创建的Actor对应的类，同时传入创建actor时所需要的构造参数。
		Props props1 = Props.create(Actor1.class, "Actor1", 1);
		Props props2 = Props.create(Actor2.class, "Actor2", 1);
		
		// 使用Props创建Actor
		final ActorSystem system = ActorSystem.create("MySystem");
		final ActorRef actor1 = system.actorOf(props1, "Actor1");
		final ActorRef actor2 = system.actorOf(props2, "Actor2");
		actor2.tell(MSG.HI, actor1);
		
		system.stop(actor1);
		system.stop(actor2);
		system.shutdown();
	}

	public static void main(String[] args) {
		communication();
	}
}

上面创造的props1，传入的参数分别是Actor1.class ，“Actor1”，1。其中"Actor1"和1对应的是构造函数的两个参数。回到Actor1，里面定义两个显示构造函数，传入的参数分别是name（String）和index（int），因此上面说的“Actor1”和1正好能够匹配成功这两个参数。props2同理。

运行上面的程序可以看到，

Actor2_1 receive message
i receive hi
Actor1_1 receive message
i receive ok
[INFO] [07/12/2014 11:24:16.189] [MySystem-akka.actor.default-dispatcher-3] [akka://MySystem/user] Message [akka.actor.StopChild] from Actor[akka://MySystem/deadLetters] to Actor[akka://MySystem/user] was not delivered. [1] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.
[INFO] [07/12/2014 11:24:16.189] [MySystem-akka.actor.default-dispatcher-3] [akka://MySystem/user] Message [akka.actor.StopChild] from Actor[akka://MySystem/deadLetters] to Actor[akka://MySystem/user] was not delivered. [2] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.

那么如果传入的参数无法和构造函数的参数匹配上，会发生什么呢？

修改props1的创建语句如下，

		Props props1 = Props.create(Actor1.class, "Actor1", 1, 2);

这种情况无法匹配任何一个构造函数，运行后出现如下信息 

Exception in thread "main" java.lang.IllegalArgumentException: no matching constructor found on class CreateTest$Actor1 for arguments [class java.lang.String, class java.lang.Integer, class java.lang.Integer]
	at akka.util.Reflect$.error$1(Reflect.scala:82)
	at akka.util.Reflect$.findConstructor(Reflect.scala:106)
	at akka.actor.ArgsReflectConstructor.<init>(Props.scala:350)
	at akka.actor.IndirectActorProducer$.apply(Props.scala:309)
	at akka.actor.Props.producer(Props.scala:176)
	at akka.actor.Props.<init>(Props.scala:189)
	at akka.actor.Props$.create(Props.scala:99)
	at akka.actor.Props$.create(Props.scala:99)
	at akka.actor.Props.create(Props.scala)
	at CreateTest.communication(CreateTest.java:66)
	at CreateTest.main(CreateTest.java:81)

很明显在这种情况下会抛出通用的IllegalArgumentException异常，而后面的error message很明确的进行了提示。

3）传入Creator<T>接口的实例

import java.util.concurrent.atomic.AtomicInteger;

import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.japi.Creator;

public class CreateTest {
	enum MSG {
		HI, OK
	}
	
	static class Creator1 implements Creator<Actor1>{
		// 多线程保证
		AtomicInteger index = new AtomicInteger();
		/**
		 * 
		 */
		private static final long serialVersionUID = 1L;

		public Actor1 create() throws Exception {
			// TODO Auto-generated method stub
			return new Actor1("Actor1", index.getAndAdd(1));
		}
		
	}
	
	static class Creator2 implements Creator<Actor2>{
		// 多线程保证
		AtomicInteger index = new AtomicInteger();
		/**
		 * 
		 */
		private static final long serialVersionUID = 1L;

		public Actor2 create() throws Exception {
			// TODO Auto-generated method stub
			return new Actor2("Actor2", index.getAndAdd(1));
		}
		
	}

	static class Actor1 extends UntypedActor {
		String name;
		int index;
		
		Actor1(String name, int index){
			this.name = name;
			this.index = index;
		}
		
		@Override
		public void onReceive(Object message) throws Exception {
			System.out.println(name + "_" + index + " receive message");
			if (message instanceof MSG) {
				if (message.equals(MSG.OK)) {
					System.out.println("i receive ok");
				} else {
					unhandled(message);
				}
			} else {
				unhandled(message);
			}

		}

	}

	static class Actor2 extends UntypedActor {
		String name;
		int index;
		
		Actor2(String name, int index){
			this.name = name;
			this.index = index;
		}
		
		@Override
		public void onReceive(Object message) throws Exception {
			System.out.println(name + "_" + index + " receive message");
			if (message instanceof MSG) {
				if (message.equals(MSG.HI)) {
					System.out.println("i receive hi");
					getSender().tell(MSG.OK, getSelf());
				} else {
					unhandled(message);
				}
			} else {
				unhandled(message);
			}
		}

	}
	
	public static void communication(){
		
		// 创建Creator实例，这个Creator用于创建Actor，然后将Creator传入到Props中
		Creator1 creator1 = new Creator1();
		Creator2 creator2 = new Creator2();
		Props props1 = Props.create(creator1);
		Props props2 = Props.create(creator2);
		
		// 使用Props创建Actor
		final ActorSystem system = ActorSystem.create("MySystem");
		final ActorRef actor1 = system.actorOf(props1);
		final ActorRef actor2 = system.actorOf(props2);
		actor2.tell(MSG.HI, actor1);
		
		system.stop(actor1);
		system.stop(actor2);
		system.shutdown();
	}

	public static void main(String[] args) {
		communication();
	}
}


这里看到Creator1和Creator2十分像一个工厂，它的create方法用于创建actor。需要注意的是，creator类必须是静态的！在创建Props的时候会进行校验。Creator<T>是一个模板类，在实现这个接口的时候指定T，就决定了这个Creator未来创建的actor的类型。

如果creator不是静态的会出现什么情况？

修改上面的代码，将Creator1定义如下，

	public class Creator1 implements Creator<Actor1>{
然后修改creator1的创建代码如下， 

		CreateTest createrTest = new CreateTest();
		Creator1 creator1 = createrTest.new Creator1();
运行代码后出现如下结果， 

Exception in thread "main" java.lang.IllegalArgumentException: cannot use non-static local Creator to create actors; make it static (e.g. local to a static method) or top-level
	at akka.actor.Props$.create(Props.scala:112)
	at akka.actor.Props.create(Props.scala)
	at CreateTest.communication(CreateTest.java:102)
	at CreateTest.main(CreateTest.java:117)

不能使用非静态的局部Creator创建actors。

Props最佳实践

在Akka文档中提到：在Actor类中定义一个静态的方法，用于获取Props是一个不错的方法，这样可以使得Props的定义与Actor的定义尽量的靠近。
根据官网上的例子我们将上面的例子中的Actor2修改如下（单独提取出来成为一个类） 
import java.util.concurrent.atomic.AtomicInteger;

import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.japi.Creator;

public class Actor2 extends UntypedActor {
	String name;
	int index;

	public Actor2(String name, int index) {
		this.name = name;
		this.index = index;
	}

	@Override
	public void onReceive(Object message) throws Exception {
		System.out.println(name + "_" + index + " receive message");
		if (message instanceof MSG) {
			if (message.equals(MSG.HI)) {
				System.out.println("i receive hi");
				getSender().tell(MSG.OK, getSelf());
			} else {
				unhandled(message);
			}
		} else {
			unhandled(message);
		}
	}

	public static Props props() {
		return Props.create(new Creator<Actor2>() {
			/**
				 * 
				 */
			private static final long serialVersionUID = 1L;
			private AtomicInteger index = new AtomicInteger();

			public Actor2 create() throws Exception {
				// TODO Auto-generated method stub
				return new Actor2("Actor2", index.getAndAdd(1));
			}
		});
	}
}

这里采用的传入匿名类的实例到create方法中。
运行后出现的错误和上面提到的一样，都是提示Creator必须是静态类。
虽然没有系统学习过Scala，但是Create方法中最开始的校验还是很明确的表示了Creator必须是静态类， 
def create[T <: Actor](creator: Creator[T]): Props = {
    val cc = creator.getClass
    if ((cc.getEnclosingClass ne null) && (cc.getModifiers & Modifier.STATIC) == 0)
      throw new IllegalArgumentException("cannot use non-static local Creator to create actors; make it static (e.g. local to a static method) or top-level")
    val ac = classOf[Actor]
    val coc = classOf[Creator[_]]
    val actorClass = Reflect.findMarker(cc, coc) match {
      case t: ParameterizedType ⇒
        t.getActualTypeArguments.head match {
          case c: Class[_] ⇒ c // since T <: Actor
          case v: TypeVariable[_] ⇒
            v.getBounds collectFirst { case c: Class[_] if ac.isAssignableFrom(c) && c != ac ⇒ c } getOrElse ac
          case x ⇒ throw new IllegalArgumentException(s"unsupported type found in Creator argument [$x]")
        }
      case c: Class[_] if (c == coc) ⇒
        throw new IllegalArgumentException(s"erased Creator types are unsupported, use Props.create(actorClass, creator) instead")
    }
    apply(defaultDeploy, classOf[CreatorConsumer], actorClass :: creator :: Nil)
  }

具体为什么这样做，不得而知。我猜想是不是因为Scala语言的特性，虽然我们可以基于Java使用Akka，但是底层的Akka包还是由Scala编写，因此其对于参数有某些要求。
既然上面的方法不行，那么怎么办呢？
在匿名类上使用eclipse快捷键ctrl+1，


选择第二个后，代码被重构为， 
import java.util.concurrent.atomic.AtomicInteger;

import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.japi.Creator;

public class Actor2 extends UntypedActor {
	private static final class CreatorImplementation implements Creator<Actor2> {
		/**
			 * 
			 */
		private static final long serialVersionUID = 1L;
		private AtomicInteger index = new AtomicInteger();

		public Actor2 create() throws Exception {
			// TODO Auto-generated method stub
			return new Actor2("Actor2", index.getAndAdd(1));
		}
	}

	String name;
	int index;

	public Actor2(String name, int index) {
		this.name = name;
		this.index = index;
	}

	@Override
	public void onReceive(Object message) throws Exception {
		System.out.println(name + "_" + index + " receive message");
		if (message instanceof MSG) {
			if (message.equals(MSG.HI)) {
				System.out.println("i receive hi");
				getSender().tell(MSG.OK, getSelf());
			} else {
				unhandled(message);
			}
		} else {
			unhandled(message);
		}
	}

	public static Props props() {
		return Props.create(new CreatorImplementation());
	}
}

原有的匿名类被显示地提取为了一个静态内部类，这种方法其实和我们最开始提到的方法相类似。

然后将Actor1按照同样的方式进行重构，修改测试类如下所示， 

import akka.actor.ActorRef;
import akka.actor.ActorSystem;

public class CreateTest {

	public void communication() {

		// 使用Props创建Actor
		final ActorSystem system = ActorSystem.create("MySystem");
		final ActorRef actor1 = system.actorOf(Actor1.props());
		final ActorRef actor2 = system.actorOf(Actor2.props());
		actor2.tell(MSG.HI, actor1);
		
		system.stop(actor1);
		system.stop(actor2);
		system.shutdown();
	}

	public static void main(String[] args) {
		new CreateTest().communication();
	}
}



运行后一切正常。 
Actor2_0 receive message
i receive hi
Actor1_0 receive message
i receive ok
[INFO] [07/13/2014 01:27:22.357] [MySystem-akka.actor.default-dispatcher-5] [akka://MySystem/user/$a] Message [akka.dispatch.sysmsg.Terminate] from Actor[akka://MySystem/user/$a#1651324613] to Actor[akka://MySystem/user/$a#1651324613] was not delivered. [1] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.
[INFO] [07/13/2014 01:27:22.359] [MySystem-akka.actor.default-dispatcher-5] [akka://MySystem/user] Message [akka.actor.StopChild] from Actor[akka://MySystem/deadLetters] to Actor[akka://MySystem/user] was not delivered. [2] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.


不同的Actor类型

顶级actor


前面的例子中创建Actor都是调用的SystemActor， 使用这种方法创建的Actor属于顶级Actor，它们由系统提供的guardian actor直接监管。

修改测试类，添加如下语句， 
		System.out.println(system.guardian().path());
		System.out.println(actor1.path());
		System.out.println(actor2.path());

运行后得到如下信息， 

akka://MySystem/user
Actor2_0 receive message
akka://MySystem/user/$a
i receive hi
akka://MySystem/user/$b
Actor1_0 receive message
i receive ok
[INFO] [07/13/2014 11:43:02.350] [MySystem-akka.actor.default-dispatcher-2] [akka://MySystem/user/$a] Message [akka.dispatch.sysmsg.Terminate] from Actor[akka://MySystem/user/$a#1387654750] to Actor[akka://MySystem/user/$a#1387654750] was not delivered. [1] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.
[INFO] [07/13/2014 11:43:02.352] [MySystem-akka.actor.default-dispatcher-2] [akka://MySystem/user] Message [akka.actor.StopChild] from Actor[akka://MySystem/deadLetters] to Actor[akka://MySystem/user] was not delivered. [2] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.

相比之前的结果，多了几个路径，路径的结构是akka://xxx/xxx/...。可以看到MySystem是我们设置的SystemActor的名字，而user是guardian actor的路径，guardian actor主要负责顶级actor的监管，这在前面已经提到了。而由于我们没有设置actor1和actor2的路径，所以系统为这两个actor生成了默认的路径$a和$b。如果设置了actor1的路径是"actor1"，那么actor1的路径就是akka://MySystem/user/actor1，actor2同理。

其他actor

使用一个actor的context可以创建这个actor的子actor。

修改Actor1，重写preStart方法， 
	@Override
	public void preStart() throws Exception {
		final ActorRef actor2 = getContext().actorOf(Actor2.props(), "actor2");
		
		actor2.tell(MSG.HI, getSelf());
		
		System.out.println(getSelf().path().parent());
		System.out.println(getSelf().path());
		System.out.println(actor2.path());
	}

修改测试类如下， 

import akka.actor.ActorRef;
import akka.actor.ActorSystem;

public class CreateTest {

	public void communication() {

		// 使用Props创建Actor
		final ActorSystem system = ActorSystem.create("MySystem");
		final ActorRef actor1 = system.actorOf(Actor1.props(), "actor1");

		system.shutdown();
	}

	public static void main(String[] args) {
		new CreateTest().communication();
	}
}

运行后得到如下信息， 
Actor2_0 receive message
i receive hi
akka://MySystem/user
akka://MySystem/user/actor1
akka://MySystem/user/actor1/actor2
Actor1_0 receive message
i receive ok

可以推出，

guardian___
                      |___actor1___
                      |___                 |___actor2

akk文档中建议：最好创建树状的结构，也就是为每个actor创建适当数量的子actor，以便其能适应应用的容错架构。
（It is recommended to create a hierarchy of children, grand-children and so on such that it fits the logical failurehandling structure of the application, see Actor Systems）

ActorRef

如论是创建顶级Actor还是非顶级Actor，actorOf的返回值类型都是ActorRef。ActorRef持有actor的实例，也是唯一可以与actor交互的。ActorRef是不变的，并且和其表示的Actor一一对应。同时ActorRef也是可序列化的，也就是说你可以序列化ActorRef，并且通过网络将其传送到远端节点，在远端主机上通过反序列化，它仍然代表了在原始节点的同一个Actor。

xlnjulp
关注
专栏目录
创建一个actor表，包含如下列信息
Alex Dou的博客
03-23 1543
题目描述 创建一个actor表，包含如下列信息 列表 类型 是否为NULL 含义 actor_id smallint(5) not null 主键i...
akka java actor_使用Akka Actor和Java 8构建反应式应用
weixin_28974441的博客
02-21 244
本文要点Actor模型为编写并发和分布式的系统提供了高层次的抽象，为开发人员屏蔽了显式锁定和线程管理的工作；Actor模型为反应式系统提供了核心功能，这些功能在反应式宣言中定义为响应性、弹性、扩展性以及消息驱动；Akka是一个基于Actor的框架，借助Java 8的Lambda支持它非常易于实现；通过使用Actor模型，开发人员在设计和实现系统时，能够更加关注于核心功能，忽略其他业务不相关的冗余内...
UE4点击UI在场景中生成actor
博客
12-29 2036
写函数showitems，创建变量wid1(类型wid1 array)，Meshs(类型create2，array)，清空之前的wid1和uniformGridpanel。宏的内容，是根据new mesh来创建对应形状的actor，将创建的actor设为变量来传给set timer循环的event中的set actor location。因为点击设置位置是在屏幕中，不是再次点击button，所以我们判定再次点击不能写在wid1中，需要创建game instance和player controller。
Akka 通过Props实例创建Actor
linuxarmsummary的专栏
02-28 1292
Props is a configuration class to specify options for the creation of actors, think of it as an immutable and thusfreely shareable recipe for creating an actor including associated deployment informat...
akka actor java_Akka:使用非默认构造函数在Scala中定义一个actor并从Java代码创建它 - java...
weixin_30366015的博客
03-05 101
Akka Scala演员必须扩展akka.actor.ActorAkka Java actor必须扩展akka.actor.UntypedActor因此，在使用非默认构造函数定义Scala actor并从Java代码创建它时，我遇到了以下问题：ActorRef myActor = system.actorOf(new Props(new UntypedActorFactory() {public ...
Akka:基于Actor的并发解决方案
qq_42885587的博客
09-11 1020
Actor模型 在面向对象编程中，一个对象可以访问或修改另一个对象的值，在高并发情况下，由于机器性能的瓶颈，当有多个对象对同一竞争资源进行操作时，可能会出现数据错误的问题（即实际读取的数据不是预期数据，而是前面阶段到这一阶段未修改完成的数据）。Actor模型对此进行了修改，它不是直接对对象进行操作，而是通过消息传递的方式与外界进行交互。如图所示： Actor一次只接收处理一个消息，未处理消息会被放入队列等待处理。 Actor有几个重要概念： Actor：处理消息并修改内部状态的工作节点。 消息：用于在多个
Akka-Actor之Hello-World
jishulaozhuanjia的博客
03-18 329
个人博客导航页（点击右侧链接即可打开个人博客）：大牛带你入门技术栈 Akka-Actor之Hello-World actor是一种并发模型，akka是使用scala语言实现这种并发模型的一个库。在akka中，消息在不同的actor之间传递，以此来驱动任务的执行，这和一般的方法调用的方式有明显的区别。 每个actor都有自己的“地址”，这个地址可以用来唯一的标示一个actor实例，每个a...
Scala---Akka Actor（二）actor创建以及Ask模式
jiexray的博客
07-28 3206
在本文中，我们将对actor的创建进行介绍，并主要讲解一下Ask模式。虽然在Actor中，更受欢迎的是Tell模式，但是我们还是有必要了解一下稍微复杂一点的Ask模式。
akka访问远程Actor
cyduo的博客
01-11 4682
akka网络编程
ActorSystem java_如何使用JAVA代码在AKKA中创建和重用ActorSystem
weixin_30413679的博客
03-01 383
首先感谢您的快速回复 .对不起，我仍然怀疑，因为我对AKKA很新 .现在我们正在运行具有3层架构的Web应用程序[动作层，业务逻辑层，数据访问对象层] .所以我需要在我的业务逻辑层之后使用AKKA .对于例如Sender_BLL_1是非Actor java类1)非Actor调用Java类import akka.actor.ActorRef;import akka.actor.ActorSystem...
Akka java 入门【二】 Actor详解
哈哈哈
04-12 2483
Akka是一个基于Actor模型的并发编程框架，它支持三种Actor类型：AbstractActor、UntypedActor和TypedActor。
Props接收父组件在created中创建的数据
SARS_的博客
04-25 1501
Props接收父组件在created中创建的数据 1.在created中创建的数据的用途 一般在created生命周期中创建的数据都是一个 常量，并不会发生改变。 因此在created中创建的数据一般都用作常量。 2.在created中创建的数据的特点 根据Vue的官方文档的描述，没有在data中初始化的数据是不具有响应式的特性。其本质是所有在生命周期data后创建的数据都不具有响应式的特性。因为数据的响应式特性会在data这个生命周期完成。 因此改变created中创建的数据时，并不会同步到页面中。 &l
vue渲染函数中的createElement的props用法详解
IT学霸
05-02 6816
一、前言 createElement函数的第二个参数中的props属性有些特殊，是一个对象类型，和自定义组件中的props的在用法上是完全不同的。 它的用途就像是给子组件提供数据，起个中间人搭桥的作用一样。具体请看下面的代码。 二、使用 这个组件定义中，显示定义了三个props变量，用于从外面接收数据。 第一个createElement函数调用中，第一个参数使用的是一个自定义组件对象，...
在create里面给props赋值，无法触发监视器效果
qq_41948178的博客
12-11 316
搜索
akka学习教程(四) actor生命周期
刘本龙的专栏
01-05 1万+
akka值actor生命周期
akka+java+教程,Akka 与 Java8 入门教程
weixin_42508215的博客
03-12 326
ActorActor 是akka 中最核心也是最基础的单位, akka 的所有消息都是基于 actor 实现的, 创建一个 actor 便可以完成消息的接收/处理/发送/转发/路由等待功能.定义一个actor, 先从构造开始package actors;import akka.actor.AbstractActor;import akka.actor.Props;/*** Created by D...
Akka in JAVA(三)
weixin_34130269的博客
01-24 241
2019独角兽企业重金招聘Python工程师标准>>> ...
akka学习教程(十三) akka分布式
热门推荐
刘本龙的专栏
01-18 9万+
akka集群概述Akka群集提供容错分散的对等群集成员服务，没有单点故障或单点瓶颈。 它使用gossip协议和自动故障检测器。
java akka 实战
最新发布
01-19
import akka.actor.AbstractActor; import akka.actor.ActorRef; import akka.actor.ActorSystem; import akka.actor.Props; // 定义一个Actor类 class MyActor extends AbstractActor { @Override public ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值