ACE学习（八）Reactor模式

React 前端之家
前端之家收集整理的这篇文章主要介绍了ACE学习（八）Reactor模式，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

这个模式为同步读+多线程处理的一个模型，在Windows下面默认的实现是ACE_WFMO_Reactor，他内部使用WaitForMuiltiObject来等待OVERLAPPED当中的event句柄，LINUX下使用ACE_Select_Reacotr实现，内部使用select函数来分配操作。

http://dl.vmall.com/c0bda5pwb4

Demo1

  1. #include "ace/Auto_Ptr.h"
  2. #include "ace/Log_Msg.h"
  3. #include "ace/INET_Addr.h"
  4. #include "ace/SOCK_Acceptor.h"
  5. #include "ace/Reactor.h"
  6. #include "ace/Message_Block.h"
  7. #include "ace/Message_Queue.h"
  8. #include "ace/SOCK_Stream.h"
  9. #include "ace/Synch_Traits.h"
  10. #include "ace/Synch.h"
  11. #include "ace/OS_NS_sys_time.h"
  12. #include "ace/os_include/os_netdb.h"
  13.  
  14.  
  15. class ClientAcceptor : public ACE_Event_Handler
  16. {
  17. public:
  18. 	virtual ~ClientAcceptor();
  19.  
  20. 	int open(const ACE_INET_Addr &listenAddr);
  21.  
  22. 	// Get this handler's I/O handle.
  23. 	virtual ACE_HANDLE get_handle(void) const
  24. 	{
  25. 		return this->m_acceptor.get_handle();
  26. 	}
  27.  
  28. 	// Called when a connection is ready to accept.
  29. 	virtual int handle_input(ACE_HANDLE fd = ACE_INVALID_HANDLE);
  30.  
  31. 	// Called when this handler is removed from the ACE_Reactor.
  32. 	virtual int handle_close(ACE_HANDLE handle,ACE_Reactor_Mask closeMask);
  33. protected:
  34. 	ACE_SOCK_Acceptor m_acceptor;
  35. };
  36.  
  37. class ClientService : public ACE_Event_Handler
  38. {
  39. public:
  40. 	int open(void);
  41. 	ACE_SOCK_Stream &peer(void)
  42. 	{
  43. 		return this->m_sock;
  44. 	}
  45.  
  46. 	// Get this handler's I/O handle.
  47. 	virtual ACE_HANDLE get_handle(void) const
  48. 	{
  49. 		return this->m_sock.get_handle();
  50. 	}
  51.  
  52. 	// Called when input is available from the client
  53. 	virtual int handle_input(ACE_HANDLE fd = ACE_INVALID_HANDLE);
  54.  
  55. 	// Called when output is possible.
  56. 	virtual int handle_output(ACE_HANDLE fd = ACE_INVALID_HANDLE);
  57.  
  58. 	// Called when this handler is removed from the ACE_Reactor.
  59. 	virtual int handle_close(ACE_HANDLE handle,ACE_Reactor_Mask close_mask);
  60.  
  61. protected:
  62. 	ACE_SOCK_Stream m_sock;
  63. 	ACE_Message_Queue<ACE_NULL_SYNCH> m_output_queue;
  64.  
  65.  
  66. };
  67.  
  68.  
  69. int ClientAcceptor::open(const ACE_INET_Addr &listenAddr)
  70. {
  71. 	if (this->m_acceptor.open(listenAddr,1) == -1)
  72. 	{
  73. 		ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("%p\n"),ACE_TEXT("acceptor.open")),-1);
  74. 	}
  75. 	/**
  76.    * Register handler for I/O events.
  77.    *
  78.    * A handler can be associated with multiple handles. A handle
  79.    * cannot be associated with multiple handlers.
  80.    *
  81.    * The handle will come from ACE_Event_Handler::get_handle().
  82.    *
  83.    * Reactor will call ACE_Event_Handler::add_reference() for a new
  84.    * handler/handle pair.
  85.    *
  86.    * If this handler/handle pair has already been registered,any new
  87.    * masks specified will be added. In this case,* ACE_Event_Handler::add_reference() will not be called.
  88.    *
  89.    * If the registered handler is currently suspended,it will remain
  90.    * suspended.  When the handler is resumed,it will have the
  91.    * existing masks plus any masks added through this call. Handlers
  92.    * do not have partial suspensions.
  93.    */
  94.  
  95. 	// Get the event demultiplexors.
  96.     // virtual ACE_Reactor *reactor (void) const;
  97. 	
  98. 	return this->reactor()->register_handler(this,ACE_Event_Handler::ACCEPT_MASK);
  99. }
  100.  
  101. int ClientAcceptor::handle_input(ACE_HANDLE)
  102. {
  103. 	// 为每次连接都使用单独的服务器处理器对象
  104. 	ClientService *client;
  105. 	ACE_NEW_RETURN (client,ClientService,-1);
  106. 	auto_ptr<ClientService> p(client);
  107.  
  108. 	// client的peer方法返回的是一个ACE_SOCK_Stream对象
  109. 	if (this->m_acceptor.accept(client->peer()) == -1)
  110. 	{
  111. 		ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("(%P|%t) %p\n"),ACE_TEXT("Failed to accept"),ACE_TEXT("client connection")),-1);
  112. 	}
  113.  
  114. 	p.release();
  115. 	client->reactor(this->reactor());
  116.  
  117. 	// open方法会向反应器登记新得ClientService实例
  118. 	if (client->open() == -1)
  119. 	{
  120. 		client->handle_close(ACE_INVALID_HANDLE,0);
  121. 	}
  122. 	return 0;
  123. }
  124.  
  125. int ClientAcceptor::handle_close(ACE_HANDLE handle,ACE_Reactor_Mask closeMask)
  126. {
  127. 	if (this->m_acceptor.get_handle() != ACE_INVALID_HANDLE)
  128. 	{
  129. 		ACE_Reactor_Mask m = ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL;
  130. 		this->reactor()->remove_handler(this,m);
  131. 		this->m_acceptor.close();
  132. 	}
  133. 	return 0;
  134. }
  135.  
  136. ClientAcceptor::~ClientAcceptor()
  137. {
  138. 	this->handle_close(ACE_INVALID_HANDLE,0);
  139. }
  140.  
  141. //--------------------------------------------------
  142. int ClientService::open(void)
  143. {
  144. 	ACE_TCHAR peer_name[128];
  145. 	ACE_INET_Addr peer_addr;
  146. 	if (this->m_sock.get_remote_addr(peer_addr) == 0 &&
  147. 		peer_addr.addr_to_string(peer_name,128) == 0)
  148. 	{
  149. 		ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) Connection from %s\n"),peer_name));
  150. 	}
  151.  
  152. 	return this->reactor()->register_handler(this,ACE_Event_Handler::READ_MASK);
  153. }
  154.  
  155. int ClientService::handle_input(ACE_HANDLE)
  156. {
  157. 	const size_t INPUT_SIZE = 4096;
  158. 	char buffer[INPUT_SIZE];
  159. 	ssize_t recv_cnt,send_cnt;
  160.  
  161. 	if (recv_cnt = (this->m_sock.recv(buffer,sizeof(buffer))) <= 0)
  162. 	{
  163. 		ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) Conection closed\n")));
  164. 		return -1;
  165. 	}
  166.  
  167. 	send_cnt = this->m_sock.send(buffer,ACE_static_cast(size_t,recv_cnt));
  168. 	if (send_cnt == recv_cnt)
  169. 	{
  170. 		return 0;
  171. 	}
  172.  
  173. 	// EWOULBLOCK无法现在发送数据
  174. 	if (send_cnt == -1 && ACE_OS::last_error() != EWOULDBLOCK)
  175. 	{
  176. 		ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("send")),0);
  177. 	}
  178.  
  179. 	if (send_cnt == -1)
  180. 	{
  181. 		send_cnt = 0;
  182. 	}
  183.  
  184. 	ACE_Message_Block *mb;
  185. 	size_t remaining = ACE_static_cast(size_t,(recv_cnt - send_cnt));
  186. 	ACE_NEW_RETURN(mb,ACE_Message_Block(&buffer[send_cnt],remaining),-1);
  187. 	int output_off = this->m_output_queue.is_empty();
  188. 	ACE_Time_Value nowait(ACE_OS::gettimeofday());
  189. 	if (this->m_output_queue.enqueue_tail(mb,&nowait) == -1)
  190. 	{
  191. 		ACE_ERROR((LM_ERROR,ACE_TEXT("(%P|%t) %p; discarding data\n"),ACE_TEXT("enqueue Failed")));
  192. 		mb->release();
  193. 		return 0;
  194. 	}
  195.  
  196. 	if (output_off)
  197. 	{
  198. 		return this->reactor()->register_handler(this,ACE_Event_Handler::WRITE_MASK);
  199. 	}
  200. 	return 0;
  201. }
  202.  
  203. int ClientService::handle_output(ACE_HANDLE)
  204. {
  205. 	ACE_Message_Block *mb;
  206. 	ACE_Time_Value nowait(ACE_OS::gettimeofday());
  207. 	while (0 == this->m_output_queue.dequeue_head(mb,&nowait))
  208. 	{
  209. 		ssize_t send_cnt = this->m_sock.send(mb->rd_ptr(),mb->length());
  210. 		if (send_cnt == -1)
  211. 		{
  212. 			ACE_ERROR((LM_ERROR,ACE_TEXT("send")));
  213. 		}
  214. 		else
  215. 		{
  216. 			mb->rd_ptr(ACE_static_cast(size_t,send_cnt));
  217. 		}
  218. 		if(mb->length() > 0)
  219. 		{
  220. 			this->m_output_queue.enqueue_head(mb);
  221. 			break;
  222. 		}
  223. 		mb->release();
  224.  
  225. 	}
  226. 	return (this->m_output_queue.is_empty()) ? -1:0;
  227. }
  228.  
  229. int ClientService::handle_close(ACE_HANDLE,ACE_Reactor_Mask mask)
  230. {
  231. 	if(mask == ACE_Event_Handler::WRITE_MASK)
  232. 		return 0;
  233. 	mask = ACE_Event_Handler::ALL_EVENTS_MASK |
  234. 		ACE_Event_Handler::DONT_CALL;
  235. 	this->reactor()->remove_handler(this,mask);
  236. 	this->m_sock.close();
  237. 	this->m_output_queue.flush();
  238. 	delete this;
  239. 	return 0;
  240. }
  241.  
  242. int ACE_TMAIN(int,ACE_TCHAR *[])
  243. {
  244. 	ACE_INET_Addr port_to_listen("5000");
  245. 	ClientAcceptor acceptor;
  246.  
  247. 	// ACE_Event_Handler含有一个ACE_Reactor指针，用于方便的引用正在使用的反应器
  248. 	// 该反应器实例会在第一次用到的时候创建，在程序结束自动关闭，单例模式+智能指针？
  249.  
  250. 	// Set the event demultiplexors.
  251.     // virtual void reactor (ACE_Reactor *reactor);
  252. 	acceptor.reactor(ACE_Reactor::instance());
  253.  
  254. 	if (acceptor.open(port_to_listen) == -1)
  255. 	{
  256. 		return 1;
  257. 	}
  258.  
  259. 	ACE_Reactor::instance()->run_reactor_event_loop();
  260. 	return 0;
  261. }


Demo2

  1. // $Id: HAStatus.cpp 91626 2010-09-07 10:59:20Z johnnyw $
  2.  
  3. #include "ace/OS_NS_sys_time.h"
  4. #include "ace/os_include/os_netdb.h"
  5.  
  6. // Listing 1 code/ch07
  7. #include "ace/Auto_Ptr.h"
  8. #include "ace/Log_Msg.h"
  9. #include "ace/INET_Addr.h"
  10. #include "ace/SOCK_Acceptor.h"
  11. #include "ace/Reactor.h"
  12.  
  13. class ClientAcceptor : public ACE_Event_Handler
  14. {
  15. public:
  16.   virtual ~ClientAcceptor ();
  17.  
  18.   //FUZZ: disable check_for_lack_ACE_OS
  19.   int open (const ACE_INET_Addr &listen_addr);
  20.   //FUZZ: enable check_for_lack_ACE_OS
  21.  
  22.   // Get this handler's I/O handle.
  23.   virtual ACE_HANDLE get_handle (void) const
  24.     { return this->acceptor_.get_handle (); }
  25.  
  26.   // Called when a connection is ready to accept.
  27.   virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE);
  28.  
  29.   // Called when this handler is removed from the ACE_Reactor.
  30.   virtual int handle_close (ACE_HANDLE handle,ACE_Reactor_Mask close_mask);
  31.  
  32. protected:
  33.   ACE_SOCK_Acceptor acceptor_;
  34. };
  35. // Listing 1
  36.  
  37. // Listing 6 code/ch07
  38. #include "ace/Message_Block.h"
  39. #include "ace/Message_Queue.h"
  40. #include "ace/SOCK_Stream.h"
  41. #include "ace/Synch.h"
  42.  
  43. class ClientService : public ACE_Event_Handler
  44. {
  45. public:
  46.   ACE_SOCK_Stream &peer (void) { return this->sock_; }
  47.  
  48.   //FUZZ: disable check_for_lack_ACE_OS
  49.   int open (void);
  50.   //FUZZ: enable check_for_lack_ACE_OS
  51.  
  52.   // Get this handler's I/O handle.
  53.   virtual ACE_HANDLE get_handle (void) const
  54.     { return this->sock_.get_handle (); }
  55.  
  56.   // Called when input is available from the client.
  57.   virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE);
  58.  
  59.   // Called when output is possible.
  60.   virtual int handle_output (ACE_HANDLE fd = ACE_INVALID_HANDLE);
  61.  
  62.   // Called when this handler is removed from the ACE_Reactor.
  63.   virtual int handle_close (ACE_HANDLE handle,ACE_Reactor_Mask close_mask);
  64.  
  65. protected:
  66.   ACE_SOCK_Stream sock_;
  67.   ACE_Message_Queue<ACE_NULL_SYNCH> output_queue_;
  68. };
  69. // Listing 6
  70.  
  71. // Listing 5 code/ch07
  72. ClientAcceptor::~ClientAcceptor ()
  73. {
  74.   this->handle_close (ACE_INVALID_HANDLE,0);
  75. }
  76. // Listing 5
  77.  
  78. // Listing 2 code/ch07
  79. int
  80. ClientAcceptor::open (const ACE_INET_Addr &listen_addr)
  81. {
  82.   if (this->acceptor_.open (listen_addr,1) == -1)
  83.     ACE_ERROR_RETURN ((LM_ERROR,ACE_TEXT ("%p\n"),ACE_TEXT ("acceptor.open")),-1);
  84.   return this->reactor ()->register_handler
  85.     (this,ACE_Event_Handler::ACCEPT_MASK);
  86. }
  87. // Listing 2
  88.  
  89. // Listing 3 code/ch07
  90. int
  91. ClientAcceptor::handle_input (ACE_HANDLE)
  92. {
  93.   ClientService *client;
  94.   ACE_NEW_RETURN (client,-1);
  95.   auto_ptr<ClientService> p (client);
  96.  
  97.   if (this->acceptor_.accept (client->peer ()) == -1)
  98.     ACE_ERROR_RETURN ((LM_ERROR,ACE_TEXT ("(%P|%t) %p\n"),ACE_TEXT ("Failed to accept ")
  99.                        ACE_TEXT ("client connection")),-1);
  100.   p.release ();
  101.   client->reactor (this->reactor ());
  102.   if (client->open () == -1)
  103.     client->handle_close (ACE_INVALID_HANDLE,0);
  104.   return 0;
  105. }
  106. // Listing 3
  107.  
  108. // Listing 4 code/ch07
  109. int
  110. ClientAcceptor::handle_close (ACE_HANDLE,ACE_Reactor_Mask)
  111. {
  112.   if (this->acceptor_.get_handle () != ACE_INVALID_HANDLE)
  113.     {
  114.       ACE_Reactor_Mask m = ACE_Event_Handler::ACCEPT_MASK |
  115.                            ACE_Event_Handler::DONT_CALL;
  116.       this->reactor ()->remove_handler (this,m);
  117.       this->acceptor_.close ();
  118.     }
  119.   return 0;
  120. }
  121. // Listing 4
  122.  
  123. // Listing 7 code/ch07
  124. int
  125. ClientService::open (void)
  126. {
  127.   ACE_TCHAR peer_name[MAXHOSTNAMELEN];
  128.   ACE_INET_Addr peer_addr;
  129.   if (this->sock_.get_remote_addr (peer_addr) == 0 &&
  130.       peer_addr.addr_to_string (peer_name,MAXHOSTNAMELEN) == 0)
  131.     ACE_DEBUG ((LM_DEBUG,ACE_TEXT ("(%P|%t) Connection from %s\n"),peer_name));
  132.   return this->reactor ()->register_handler
  133.     (this,ACE_Event_Handler::READ_MASK);
  134. }
  135. // Listing 7
  136.  
  137. // Listing 8 code/ch07
  138. int
  139. ClientService::handle_input (ACE_HANDLE)
  140. {
  141.   const size_t INPUT_SIZE = 4096;
  142.   char buffer[INPUT_SIZE];
  143.   ssize_t recv_cnt,send_cnt;
  144.  
  145.   if ((recv_cnt = this->sock_.recv (buffer,sizeof(buffer))) <= 0)
  146.     {
  147.       ACE_DEBUG ((LM_DEBUG,ACE_TEXT ("(%P|%t) Connection closed\n")));
  148.       return -1;
  149.     }
  150.  
  151.   send_cnt =
  152.     this->sock_.send (buffer,static_cast<size_t> (recv_cnt));
  153.   if (send_cnt == recv_cnt)
  154.     return 0;
  155.   if (send_cnt == -1 && ACE_OS::last_error () != EWOULDBLOCK)
  156.     ACE_ERROR_RETURN ((LM_ERROR,ACE_TEXT ("send")),0);
  157.   if (send_cnt == -1)
  158.     send_cnt = 0;
  159.   ACE_Message_Block *mb = 0;
  160.   size_t remaining =
  161.     static_cast<size_t> ((recv_cnt - send_cnt));
  162.   ACE_NEW_RETURN (mb,ACE_Message_Block (remaining),-1);
  163.   mb->copy (&buffer[send_cnt],remaining);
  164.   int output_off = this->output_queue_.is_empty ();
  165.   ACE_Time_Value nowait (ACE_OS::gettimeofday ());
  166.   if (this->output_queue_.enqueue_tail (mb,&nowait) == -1)
  167.     {
  168.       ACE_ERROR ((LM_ERROR,ACE_TEXT ("(%P|%t) %p; discarding data\n"),ACE_TEXT ("enqueue Failed")));
  169.       mb->release ();
  170.       return 0;
  171.     }
  172.   if (output_off)
  173.     return this->reactor ()->register_handler
  174.       (this,ACE_Event_Handler::WRITE_MASK);
  175.   return 0;
  176. }
  177. // Listing 8
  178.  
  179. // Listing 9 code/ch07
  180. int
  181. ClientService::handle_output (ACE_HANDLE)
  182. {
  183.   ACE_Message_Block *mb = 0;
  184.   ACE_Time_Value nowait (ACE_OS::gettimeofday ());
  185.   while (0 <= this->output_queue_.dequeue_head
  186.                                     (mb,&nowait))
  187.     {
  188.       ssize_t send_cnt =
  189.         this->sock_.send (mb->rd_ptr (),mb->length ());
  190.       if (send_cnt == -1)
  191.         ACE_ERROR ((LM_ERROR,ACE_TEXT ("send")));
  192.       else
  193.         mb->rd_ptr (static_cast<size_t> (send_cnt));
  194.       if (mb->length () > 0)
  195.         {
  196.           this->output_queue_.enqueue_head (mb);
  197.           break;
  198.         }
  199.       mb->release ();
  200.     }
  201.   return (this->output_queue_.is_empty ()) ? -1 : 0;
  202. }
  203. // Listing 9
  204.  
  205. // Listing 10 code/ch07
  206. int
  207. ClientService::handle_close (ACE_HANDLE,ACE_Reactor_Mask mask)
  208. {
  209.   if (mask == ACE_Event_Handler::WRITE_MASK)
  210.     return 0;
  211.   mask = ACE_Event_Handler::ALL_EVENTS_MASK |
  212.          ACE_Event_Handler::DONT_CALL;
  213.   this->reactor ()->remove_handler (this,mask);
  214.   this->sock_.close ();
  215.   this->output_queue_.flush ();
  216.   delete this;
  217.   return 0;
  218. }
  219. // Listing 10
  220.  
  221. // Listing 12 code/ch07
  222. class LoopStopper : public ACE_Event_Handler
  223. {
  224. public:
  225.   LoopStopper (int signum = SIGINT);
  226.  
  227.   // Called when object is signaled by OS.
  228.   virtual int handle_signal (int signum,siginfo_t * = 0,ucontext_t * = 0);
  229. };
  230.  
  231. LoopStopper::LoopStopper (int signum)
  232. {
  233.   ACE_Reactor::instance ()->register_handler (signum,this);
  234. }
  235.  
  236. int
  237. LoopStopper::handle_signal (int,siginfo_t *,ucontext_t *)
  238. {
  239.   ACE_Reactor::instance ()->end_reactor_event_loop ();
  240.   return 0;
  241. }
  242. // Listing 12
  243.  
  244. // Listing 13 code/ch07
  245. #include "ace/Signal.h"
  246.  
  247. class LogSwitcher : public ACE_Event_Handler
  248. {
  249. public:
  250.   LogSwitcher (int on_sig,int off_sig);
  251.  
  252.   // Called when object is signaled by OS.
  253.   virtual int handle_signal (int signum,ucontext_t * = 0);
  254.  
  255.   // Called when an exceptional event occurs.
  256.   virtual int handle_exception (ACE_HANDLE fd = ACE_INVALID_HANDLE);
  257.  
  258. private:
  259.   LogSwitcher () {}
  260.  
  261.   int on_sig_;       // Signal to turn logging on
  262.   int off_sig_;      // Signal to turn logging off
  263.   int on_off_;       // 1 == turn on,0 == turn off
  264. };
  265.  
  266. LogSwitcher::LogSwitcher (int on_sig,int off_sig)
  267.   : on_sig_ (on_sig),off_sig_ (off_sig)
  268. {
  269.   ACE_Sig_Set sigs;
  270.   sigs.sig_add (on_sig);
  271.   sigs.sig_add (off_sig);
  272.   ACE_Reactor::instance ()->register_handler (sigs,this);
  273. }
  274. // Listing 13
  275.  
  276. // Listing 14 code/ch07
  277. int
  278. LogSwitcher::handle_signal (int signum,ucontext_t *)
  279. {
  280.   if (signum == this->on_sig_ || signum == this->off_sig_)
  281.     {
  282.       this->on_off_ = signum == this->on_sig_;
  283.       ACE_Reactor::instance ()->notify (this);
  284.     }
  285.   return 0;
  286. }
  287. // Listing 14
  288.  
  289. // Listing 15 code/ch07
  290. int
  291. LogSwitcher::handle_exception (ACE_HANDLE)
  292. {
  293.   if (this->on_off_)
  294.     ACE_LOG_MSG->clr_flags (ACE_Log_Msg::SILENT);
  295.   else
  296.     ACE_LOG_MSG->set_flags (ACE_Log_Msg::SILENT);
  297.   return 0;
  298. }
  299. // Listing 15
  300.  
  301. // Listing 11 code/ch07
  302. int ACE_TMAIN (int,ACE_TCHAR *[])
  303. {
  304.   ACE_INET_Addr port_to_listen ("HAStatus");
  305.   ClientAcceptor acceptor;
  306.   acceptor.reactor (ACE_Reactor::instance ());
  307.   if (acceptor.open (port_to_listen) == -1)
  308.     return 1;
  309.  
  310.   ACE_Reactor::instance ()->run_reactor_event_loop ();
  311.  
  312.   return (0);
  313. }
  314. // Listing 11


http://wenku.baidu.com/view/866966a1284ac850ad0242ab.html
http://daimojingdeyu.iteye.com/blog/828696
http://book.2cto.com/201208/1893.html
http://www.jb51.cc/article/p-nlrfvpff-yn.html
http://developer.51cto.com/art/201208/354591.htm

acceptor-connector

http://shanghai.kankanews.com/mobile/2013-05-20/1546541.shtml
http://auto.people.com.cn/n/2013/0317/c1005-20815213.html
http://scitech.people.com.cn/n/2013/0310/c1007-20736417.html

猜你在找的React相关文章

react使用moment进行日期格式化
导入moment 使用方式 年月日，时分秒 星期几 相对时间 7天后 2小时后 明天 将毫秒转换成年...
推荐使用并手写实现redux-actions原理
@ 一、前言 为什么介绍redux-actions呢? 第一次见到主要是接手公司原有的项目，发现有之前...
【译】值得推荐的十大React Hook 库
十大React Hook库 原文地址：https://dev.to/bornfightcompany/top-10-react-hook-librari...
React生命周期
React生命周期 React的生命周期从广义上分为挂载、渲染、卸载三个阶段，在React的整个生命...
React虚拟DOM的理解
React虚拟DOM的理解 Virtual DOM是一棵以JavaScript对象作为基础的树，每一个节点可以将其...
使用react-native-vector-icons（RN0.6+）
1.安装 npm install --save react-native-vector-icons or yarn add react-native-vector-...
React中的Props, State 与 render 函数
React 的核心特性总结 1、React：声明式开发 (JS或者jQuery属性命令式开发） 2、可以与其他...
React开发环境准备
react fiber 指react 16以上的版本 引入react的方式： 1、引入.js文件 2、使用脚手架工具（...
React组件拆分与传值
组件拆分与组件之间的传值 父子组件的概念： 父组件通过属性的方式，向自组件传值 子组件通...
React组件的简单演示
src/Test.js import React from &#39;react&#39;; function Test() { return ( &a...
HTMLHTML5JavaScriptCSSjQueryBootstrapAngularjsTypeScriptVueDojoJsonElectronNode.jsextjsExpress XMLES6AjaxFlashUnityReactFlexAnt DesignWeb前端微信小程序微信公众号
关闭广告单独headers封装代码提示错误整数正则非0开头跳页出页码antd table提示URL未注册公众号支付vue hash模式iSlider车牌键盘循环图片echarts 双折左右布局DllPlugin对象创建打字游戏圈选两栏云函数蒙版ES2020橱窗无缝滚动轮播色块碰撞组件销毁文档操作