因为该模式降低了服务和连接建立方法之间的耦合，非常容易改动其中一个，而不影响另外一个，从而也就可以复用以前编写的连接建立机制和服务例程的代码。在同样的例子中，使用这些模式的浏览器程序员一开始可以构造他的系统、使用特定的连接建立机制来运行它和测试它；然后，如果先前的连接机制被证明不适合他所构造的系统，他可以决定说他希望将底层连接机制改变为多线程的（或许使用线程池策略）。因为此模式提供了严格的去耦合，只需要极少的努力就可以实现这样的变动。

• 被动连接建立
• 连接建立后的处理

　　下面的讨论同时适用于接受器和连接器，所以作者将只讨论接受器，而连接器同样具有相应的参数。

typedef ACE_Acceptor<My_Service_Handler,ACE_SOCK_ACCEPTOR> MyAcceptor;

#define ACE_SOCK_ACCEPTOR ACE_SOCK_Acceptor, ACE_INET_Addr

typedef ACE_Acceptor<My_Service_Handler,ACE_SOCK_Acceptor>MyAcceptor;

　　如上面的讨论所说明的，在接受器模式中有三个主要的参与类：

　　通过观察一个简单的例子，可以进一步了解接受器。这个例子是一个简单的应用，它使用接受器接受连接，随后回调服务例程。当服务例程被回调时，它就让用户知道连接已经被成功地建立。

#include ”ace/Reactor.h”

#include ”ace/Svc_Handler.h”

#include ”ace/Acceptor.h”

#include ”ace/Synch.h”

#include ”ace/SOCK_Acceptor.h”

//Create a Service Handler whose open() method will be called back

//is ACE_SOCK_STREAM. The second is the internal synchronization

class My_Svc_Handler:

public ACE_Svc_Handler <ACE_SOCK_STREAM,ACE_NULL_SYNCH>

{

//the open method which will be called back automatically after the

public:

int open(void*)

{

cout<<”Connection established”<<endl;

}

};

// Create the acceptor as described above.

typedef ACE_Acceptor<My_Svc_Handler,ACE_SOCK_ACCEPTOR> MyAcceptor;

int main(int argc, char* argv[])

{

//create the address on which we wish to connect. The constructor takes

ACE_INET_Addr addr(PORT_NUM);

//instantiate the appropriate acceptor object with the address on which

//the reactor in the previous chapter)

MyAcceptor acceptor(addr, ACE_Reactor::instance());

while(1)

// Start the reactor’s event loop

ACE_Reactor::instance()->handle_events();

}

#include ”ace/Reactor.h”

#include ”ace/Svc_Handler.h”

#include ”ace/Acceptor.h”

#include ”ace/Synch.h”

#include ”ace/SOCK_Acceptor.h”

#define PORT_NUM 10101

#define DATA_SIZE 12

//forward declaration

class My_Svc_Handler;

//Create the Acceptor class

typedef ACE_Acceptor<My_Svc_Handler,ACE_SOCK_ACCEPTOR>

MyAcceptor;

//Create a service handler similar to as seen in example 1. Except this

//time include the handle_input() method which will be called back

//automatically by the reactor when new data arrives on the newly

//established connection

class My_Svc_Handler:

public ACE_Svc_Handler <ACE_SOCK_STREAM,ACE_NULL_SYNCH>

{

public:

My_Svc_Handler()

{

data= new char[DATA_SIZE];

}

int open(void*)

{

cout<<”Connection established”<<endl;

　

//Register the service handler with the reactor

ACE_Reactor::instance()->register_handler(this,

ACE_Event_Handler::READ_MASK);

　

return 0;

}

int handle_input(ACE_HANDLE)

{

//After using the peer() method of ACE_Svc_Handler to obtain a

//reference to the underlying stream of the service handler class

//we call recv_n() on it to read the data which has been received.

//This data is stored in the data array and then printed out

peer().recv_n(data,DATA_SIZE);

ACE_OS::printf(”<< %s\n”,data);

　

//keep yourself registered with the reactor

return 0;

}

private:

char* data;

};

int main(int argc, char* argv[])

{

ACE_INET_Addr addr(PORT_NUM);

//create the acceptor

MyAcceptor acceptor(addr, //address to accept on

ACE_Reactor::instance()); //the reactor to use

　

while(1)

//Start the reactor’s event loop

ACE_Reactor::instance()->handle_events();

}

class My_Svc_Handler:

public ACE_Svc_Handler <ACE_LSOCK_STREAM,ACE_NULL_SYNCH>{

public:

int open(void*)

{

cout<<”Connection established”<<endl;

ACE_Reactor::instance()

->register_handler(this,ACE_Event_Handler::READ_MASK);

}

int handle_input(ACE_HANDLE)

{

char* data= new char[DATA_SIZE];

peer().recv_n(data,DATA_SIZE);

ACE_OS::printf(”<< %s\n”,data);

return 0;

}

};

typedef ACE_Acceptor<My_Svc_Handler,ACE_LSOCK_ACCEPTOR> MyAcceptor;

int main(int argc, char* argv[])

{

MyAcceptor acceptor(address, ACE_Reactor::instance());

　

while(1) /* Start the reactor’s event loop */

ACE_Reactor::instance()->handle_events();

}

typedef ACE_Connector<My_Svc_Handler,ACE_SOCK_CONNECTOR> MyConnector;

　　一个使用连接器的例子可以进一步说明这一点：

typedef ACE_Connector<My_Svc_Handler,ACE_SOCK_CONNECTOR> MyConnector;

int main(int argc, char * argv[])

{

ACE_INET_Addr addr(PORT_NO,HOSTNAME);

My_Svc_Handler * handler= new My_Svc_Handler;

//Create the connector

MyConnector connector;

//Connects to remote machine

if(connector.connect(handler,addr)==-1)

ACE_ERROR(LM_ERROR,”%P|%t, %p”,”Connection failed”);

　

//Registers with the Reactor

while(1)

ACE_Reactor::instance()->handle_events();

}

#include ”ace/Reactor.h”

#include ”ace/Svc_Handler.h”

#include ”ace/Acceptor.h”

#include ”ace/Synch.h”

#include ”ace/SOCK_Acceptor.h”

#include ”ace/Thread.h”

//Add our own Reactor singleton

typedef ACE_Singleton<ACE_Reactor,ACE_Null_Mutex> Reactor;

//Create an Acceptor

typedef ACE_Acceptor<MyServiceHandler,ACE_SOCK_ACCEPTOR> Acceptor;

//Create a Connector

typedef ACE_Connector<MyServiceHandler,ACE_SOCK_CONNECTOR> Connector;

class MyServiceHandler:

public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_NULL_SYNCH>

{

public:

//Used by the two threads “globally” to determine their peer stream

static ACE_SOCK_Stream* Peer;

//Thread ID used to identify the threads

ACE_thread_t t_id;

int open(void*)

{

cout<<”Acceptor: received new connection”<<endl;

　

//Register with the reactor to remember this handle

Reactor::instance()

->register_handler(this,ACE_Event_Handler::READ_MASK);

　

//Determine the peer stream and record it globally

MyServiceHandler::Peer=&peer();

　

//Spawn new thread to send string every second

ACE_Thread::spawn((ACE_THR_FUNC)send_data,0,THR_NEW_LWP,&t_id);

　

//keep the service handler registered by returning 0 to the

//reactor

return 0;

}

static void* send_data(void*)

{

while(1)

{

cout<<”>>Hello World”<<endl;

Peer->send_n(”Hello World”,sizeof(”Hello World”));

　

//Go to sleep for a second before sending again

ACE_OS::sleep(1);

}

　

return 0;

}

int handle_input(ACE_HANDLE)

{

char* data= new char[12];

　

//Check if peer aborted the connection

if(Peer.recv_n(data,12)==0)

{

cout<<”Peer probably aborted connection”);

ACE_Thread::cancel(t_id); //kill sending thread ..

return -1; //de-register from the Reactor.

}

　

//Show what you got..

cout<<”<< %s\n”,data”<<endl;

　

//keep yourself registered

return 0;

}

};

//Global stream identifier used by both threads

ACE_SOCK_Stream * MyServiceHandler::Peer=0;

void main_accept()

{

ACE_INET_Addr addr(PORT_NO);

Acceptor myacceptor(addr,Reactor::instance());

while(1)

Reactor::instance()->handle_events();

　

return 0;

}

void main_connect()

{

ACE_INET_Addr addr(PORT_NO,HOSTNAME);

Connector myconnector;

myconnector.connect(my_svc_handler,addr);

while(1)

Reactor::instance()->handle_events();

}

int main(int argc, char* argv[])

{

// Use ACE_Get_Opt to parse and obtain arguments and then call the

// appropriate function for accept or connect.

...

}

这个简单的例子演示怎样联合使用接受器和连接模式来生成服务处理例程，该例程与底层的网络连接建立方法是完全分离的。通过改变相应的设定具体连接器和接受器的模板参数，可以很容易地改用任何其他的底层网络连接建立协议。

class MySvcHandler:

public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_MT_SYNCH>

{

...

}

// = Active object activation method.

virtual int activate (long flags = THR_NEW_LWP,

int n_threads = 1,

int force_active = 0,

long priority = ACE_DEFAULT_THREAD_PRIORITY,

int grp_id = -1,

ACE_Task_Base *task = 0,

ACE_hthread_t thread_handles[] = 0,

void *stack[] = 0,

size_t stack_size[] = 0,

ACE_thread_t thread_names[] = 0);

THR_CANCEL_DISABLE, THR_CANCEL_ENABLE, THR_CANCEL_DEFERRED,

THR_CANCEL_ASYNCHRONOUS, THR_BOUND, THR_NEW_LWP, THR_DETACHED,

THR_SUSPENDED, THR_DAEMON, THR_JOINABLE, THR_SCHED_FIFO,

THR_SCHED_RR, THR_SCHED_DEFAULT

#include ”ace/Reactor.h”

#include ”ace/Svc_Handler.h”

#include ”ace/Acceptor.h”

#include ”ace/Synch.h”

#include ”ace/SOCK_Acceptor.h”

class MyServiceHandler; //forward declaration

typedef ACE_Singleton<ACE_Reactor,ACE_Null_Mutex> Reactor;

typedef ACE_Acceptor<MyServiceHandler,ACE_SOCK_ACCEPTOR> Acceptor;

class MyServiceHandler:

public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_MT_SYNCH>

{

// The two thread names are kept here

ACE_thread_t thread_names[2];

public:

int open(void*)

{

ACE_DEBUG((LM_DEBUG, ”Acceptor: received new connection \n”));

　

//Register with the reactor to remember this handler..

Reactor::instance()

->register_handler(this,ACE_Event_Handler::READ_MASK);

ACE_DEBUG((LM_DEBUG,”Acceptor: ThreadID:(%t) open\n”));

　

//Create two new threads to create and send messages to the

//remote machine.

activate(THR_NEW_LWP,

2, //2 new threads

0, //force active false, if already created don’t try again.

ACE_DEFAULT_THREAD_PRIORITY,//Use default thread priority

-1,

this,//Which ACE_Task object to create? In this case this one.

0,// don’t care about thread handles used

0,// don’t care about where stacks are created

0,//don’t care about stack sizes

thread_names); // keep identifiers in thread_names

　

//keep the service handler registered with the acceptor.

return 0;

}

void send_message1(void)

{

//Send message type 1

ACE_DEBUG((LM_DEBUG,”(%t)Sending message::>>”));

　

//Send the data to the remote peer

ACE_DEBUG((LM_DEBUG,”Sent message1”));

peer().send_n(”Message1”,LENGTH_MSG_1);

} //end send_message1

int send_message2(void)

{

//Send message type 1

ACE_DEBUG((LM_DEBUG,”(%t)Sending message::>>”));

　

//Send the data to the remote peer

ACE_DEBUG((LM_DEBUG,”Sent Message2”));

peer().send_n(”Message2”,LENGTH_MSG_2);

}//end send_message_2

　

int svc(void)

{

ACE_DEBUG( (LM_DEBUG,”(%t) Svc thread \n”));

if(ACE_Thread::self()== thread_names[0])

while(1) send_message1(); //send message 1s forever

else

while(1) send_message2(); //send message 2s forever

　

return 0; // keep the compiler happy.

}

int handle_input(ACE_HANDLE)

{

ACE_DEBUG((LM_DEBUG,”(%t) handle_input ::”));

char* data= new char[13];

　

//Check if peer aborted the connection

if(peer().recv_n(data,12)==0)

{

printf(”Peer probably aborted connection”);

return -1; //de-register from the Reactor.

}

　

//Show what you got..

ACE_OS::printf(”<< %s\n”,data);

　

//keep yourself registered

return 0;

}

};

int main(int argc, char* argv[])

{

ACE_INET_Addr addr(10101);

ACE_DEBUG((LM_DEBUG,”Thread: (%t) main”));

//Prepare to accept connections

Acceptor myacceptor(addr,Reactor::instance());

// wait for something to happen.

while(1)

Reactor::instance()->handle_events();

　

return 0;

}

　　下面的例子演示怎样使用消息队列的一些功能：

#include ”ace/Reactor.h”

#include ”ace/Svc_Handler.h”

#include ”ace/Acceptor.h”

#include ”ace/Synch.h”

#include ”ace/SOCK_Acceptor.h”

#include ”ace/Thread.h”

#define NETWORK_SPEED 3

class MyServiceHandler; //forward declaration

typedef ACE_Singleton<ACE_Reactor,ACE_Null_Mutex> Reactor;

typedef ACE_Acceptor<MyServiceHandler,ACE_SOCK_ACCEPTOR> Acceptor;

class MyServiceHandler:

public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_MT_SYNCH>{

// The message sender and creator threads are handled here.

ACE_thread_t thread_names[2];

public:

int open(void*)

{

ACE_DEBUG((LM_DEBUG, ”Acceptor: received new connection \n”));

　

//Register with the reactor to remember this handler..

Reactor::instance()

->register_handler(this,ACE_Event_Handler::READ_MASK);

ACE_DEBUG((LM_DEBUG,”Acceptor: ThreadID:(%t) open\n”));

　

//Create two new threads to create and send messages to the

//remote machine.

activate(THR_NEW_LWP,

2, //2 new threads

0,

ACE_DEFAULT_THREAD_PRIORITY,

-1,

this,

0,

0,

0,

thread_names); // identifiers in thread_handles

　

//keep the service handler registered with the acceptor.

return 0;

}

void send_message(void)

{

//Dequeue the message and send it off

ACE_DEBUG((LM_DEBUG,”(%t)Sending message::>>”));

　

//dequeue the message from the message queue

ACE_Message_Block *mb;

ACE_ASSERT(this->getq(mb)!=-1);

int length=mb->length();

char *data =mb->rd_ptr();

　

//Send the data to the remote peer

ACE_DEBUG((LM_DEBUG,”%s \n”,data,length));

peer().send_n(data,length);

　

//Simulate very SLOW network.

ACE_OS::sleep(NETWORK_SPEED);

　

//release the message block

mb->release();

} //end send_message

int construct_message(void)

{

// A very fast message creation algorithm

// would lead to the need for queuing messages..

// here. These messages are created and then sent

// using the SLOW send_message() routine which is

// running in a different thread so that the message

//construction thread isn’t blocked.

ACE_DEBUG((LM_DEBUG,”(%t)Constructing message::>> ”));

　

// Create a new message to send

ACE_Message_Block *mb;

char *data=”Hello Connector”;

ACE_NEW_RETURN (mb,ACE_Message_Block (16,//Message 16 bytes long

ACE_Message_Block::MB_DATA,//Set header to data

0,//No continuations.

data//The data we want to send

), 0);

mb->wr_ptr(16); //Set the write pointer.

　

// Enqueue the message into the message queue

// we COULD have done a timed wait for enqueuing in case

// someone else holds the lock to the queue so it doesn’t block

//forever..

ACE_ASSERT(this->putq(mb)!=-1);

ACE_DEBUG((LM_DEBUG,”Enqueued msg successfully\n”));

}

int svc(void)

{

ACE_DEBUG( (LM_DEBUG,”(%t) Svc thread \n”));

　

//call the message creator thread

if(ACE_Thread::self()== thread_names[0])

while(1) construct_message(); //create messages forever

else

while(1) send_message(); //send messages forever

　

return 0; // keep the compiler happy.

}

int handle_input(ACE_HANDLE)

{

ACE_DEBUG((LM_DEBUG,”(%t) handle_input ::”));

char* data= new char[13];

　

//Check if peer aborted the connection

if(peer().recv_n(data,12)==0)

{

printf(”Peer probably aborted connection”);

return -1; //de-register from the Reactor.

}

　

//Show what you got..

ACE_OS::printf(”<< %s\n”,data);

　

//keep yourself registered

return 0;

}

};

int main(int argc, char* argv[])

{

ACE_INET_Addr addr(10101);

ACE_DEBUG((LM_DEBUG,”Thread: (%t) main”));

//Prepare to accept connections

Acceptor myacceptor(addr,Reactor::instance());

// wait for something to happen.

while(1)

Reactor::instance()->handle_events();

　

return 0;

}

//Synchronous

OurConnector.connect_n(NUMBER_CONN,ArrayofMySvcHandlers,Remote_Addr,0,

ACE_Synch_Options::synch);

　

//Asynchronous

OurConnector.connect_n(NUMBER_CONN,ArrayofMySvcHandlers,Remote_Addr,0,

　　在我们的这个案例中，模板方法将算法定义如下：

　　这些方法都可以被重新编写，从而灵活地决定这些操作怎样来实际执行。

　　每一方法都可以被重新编写，从而灵活地决定这些操作怎样来实际执行。

　　如上面所提到的，因为使用了可以重载的桥接方法，很容易对接受器和连接器进行调谐。桥接方法允许调谐：

　　下面的例子演示策略接受器和连接器类的使用。

#include ”ace/Reactor.h”

#include ”ace/Svc_Handler.h”

#include ”ace/Acceptor.h”

#include ”ace/Synch.h”

#include ”ace/SOCK_Acceptor.h”

#define PORT_NUM 10101

#define DATA_SIZE 12

//forward declaration

class My_Svc_Handler;

// Define the Service Handler

class My_Svc_Handler:

public ACE_Svc_Handler <ACE_SOCK_STREAM,ACE_NULL_SYNCH>

{

private:

char* data;

public:

My_Svc_Handler()

{

data= new char[DATA_SIZE];

}

My_Svc_Handler(ACE_Thread_Manager* tm)

{

data= new char[DATA_SIZE];

}

int open(void*)

{

cout<<”Connection established”<<endl;

　

//Register with the reactor

ACE_Event_Handler::READ_MASK);

　

return 0;

}

int handle_input(ACE_HANDLE)

{

peer().recv_n(data,DATA_SIZE);

ACE_OS::printf(”<< %s\n”,data);

　

// keep yourself registered with the reactor

return 0;

}

};

int main(int argc, char* argv[])

{

ACE_INET_Addr addr(PORT_NUM);

//Instantiate the acceptor

MyAcceptor acceptor(addr, //address to accept on

while(1) /* Start the reactor’s event loop */

ACE_Reactor::instance()->handle_events();

}

#include ”ace/Reactor.h”

#include ”ace/Svc_Handler.h”

#include ”ace/Connector.h”

#include ”ace/Synch.h”

#include ”ace/SOCK_Connector.h”

#include ”ace/INET_Addr.h”

#define PORT_NUM 10101

#define DATA_SIZE 16

//forward declaration

class My_Svc_Handler;

//Function prototype

static void make_connections(void *arg);

// Template specializations for the hashing function for the

// hash_map which is used by the cache. The cache is used internally by the

// Cached Connection Strategy . Here we use ACE_Hash_Addr

// as our external identifier. This utility class has already

// overloaded the == operator and the hash() method. (The

// hashing function). The hash() method delegates the work to

// hash_i() and we use the IP address and port to get a

// a unique integer hash value.

size_t ACE_Hash_Addr<ACE_INET_Addr>::hash_i (const ACE_INET_Addr &addr) const

{

return addr.get_ip_address () + addr.get_port_number ();

}

//instantiate a strategy acceptor

typedef ACE_Strategy_Connector<My_Svc_Handler,ACE_SOCK_CONNECTOR>

STRATEGY_CONNECTOR;

//Instantiate the Creation Strategy

typedef ACE_NOOP_Creation_Strategy<My_Svc_Handler>

NULL_CREATION_STRATEGY;

//Instantiate the Concurrency Strategy

typedef ACE_NOOP_Concurrency_Strategy<My_Svc_Handler>

NULL_CONCURRENCY_STRATEGY;

//Instantiate the Connection Strategy

typedef ACE_Cached_Connect_Strategy<My_Svc_Handler,

ACE_SOCK_CONNECTOR,

ACE_SYNCH_RW_MUTEX>

CACHED_CONNECT_STRATEGY;

class My_Svc_Handler:

public ACE_Svc_Handler <ACE_SOCK_STREAM,ACE_MT_SYNCH>

{

private:

char* data;

public:

My_Svc_Handler()

{

data= new char[DATA_SIZE];

}

My_Svc_Handler(ACE_Thread_Manager* tm)

{

data= new char[DATA_SIZE];

}

//Called before the service handler is recycled..

{

ACE_DEBUG ((LM_DEBUG,

”(%P|%t) recycling Svc_Handler %d with handle %d\n”,

this, this->peer ().get_handle ()));

return 0;

}

int open(void*)

{

ACE_DEBUG((LM_DEBUG,”(%t)Connection established \n”));

　

//Register the service handler with the reactor

ACE_Reactor::instance()

->register_handler(this,ACE_Event_Handler::READ_MASK);

　

activate(THR_NEW_LWP|THR_DETACHED);

return 0;

}

int handle_input(ACE_HANDLE)

{

ACE_DEBUG((LM_DEBUG,”Got input in thread: (%t) \n”));

peer().recv_n(data,DATA_SIZE);

ACE_DEBUG((LM_DEBUG,”<< %s\n”,data));

　

//keep yourself registered with the reactor

return 0;

}

int svc(void)

{

}

};

ACE_INET_Addr *addr;

int main(int argc, char* argv[])

{

addr= new ACE_INET_Addr(PORT_NUM,argv[1]);

//Creation Strategy

NULL_CREATION_STRATEGY creation_strategy;

//Concurrency Strategy

NULL_CONCURRENCY_STRATEGY concurrency_strategy;

//Connection Strategy

CACHED_CONNECT_STRATEGY caching_connect_strategy;

//instantiate the connector

STRATEGY_CONNECTOR connector(

ACE_Reactor::instance(), //the reactor to use

&creation_strategy,

&caching_connect_strategy,

&concurrency_strategy);

　

//Use the thread manager to spawn a single thread

//to connect multiple times passing it the address

//of the strategy connector

if(ACE_Thread_Manager::instance()->spawn(

(ACE_THR_FUNC) make_connections,

(void *) &connector,

THR_NEW_LWP) == -1)

　

ACE_ERROR ((LM_ERROR, ”(%P|%t) %p\n%a”, ”client thread spawn failed”));

while(1) /* Start the reactor’s event loop */

ACE_Reactor::instance()->handle_events();

}

//Connection establishment function, tries to establish connections

//to the same server again and re-uses the connections from the cache

void make_connections(void *arg)

{

ACE_DEBUG((LM_DEBUG,”(%t)Prepared to connect \n”));

STRATEGY_CONNECTOR *connector= (STRATEGY_CONNECTOR*) arg;

for (int i = 0; i < 10; i++)

{

My_Svc_Handler *svc_handler = 0;

　

// Perform a blocking connect to the server using the Strategy

// Connector with a connection caching strategy. Since we are

// connecting to the same <server_addr> these calls will return the

// same dynamically allocated <Svc_Handler> for each <connect> call.

if (connector->connect (svc_handler, *addr) == -1)

{

ACE_ERROR ((LM_ERROR, ”(%P|%t) %p\n”, ”connection failed\n”));

return;

}

　

// Rest for a few seconds so that the connection has been freed up

ACE_OS::sleep (5);

}

　　这个例子比至今为止我们所列举的例子都要复杂一点，所以有理由多进行一点讨论。

#include ”ace/Reactor.h”

#include ”ace/Svc_Handler.h”

#include ”ace/Acceptor.h”

#include ”ace/Synch.h”

#include ”ace/SOCK_Acceptor.h”

#define PORT_NUM 10101

#define DATA_SIZE 12

//forward declaration

class My_Event_Handler;

//Create the Acceptor class

typedef ACE_Acceptor<My_Event_Handler,ACE_SOCK_ACCEPTOR>

MyAcceptor;

//Create an event handler similar to as seen in example 2. We have to

//overload the get_handle() method and write the peer() method. We also

//provide the data member peer_ as the underlying stream which is

//used.

class My_Event_Handler: public ACE_Event_Handler

{

private:

char* data;

//Add a new attribute for the underlying stream which will be used by

//the Event Handler

ACE_SOCK_Stream peer_;

public:

My_Event_Handler()

{

data= new char[DATA_SIZE];

}

int open(void*)

{

cout<<”Connection established”<<endl;

　

//Register the event handler with the reactor

ACE_Reactor::instance()->register_handler(this,

ACE_Event_Handler::READ_MASK);

　

return 0;

}

int handle_input(ACE_HANDLE)

{

// After using the peer() method of our ACE_Event_Handler to obtain a

//reference to the underlying stream of the service handler class we

//call recv_n() on it to read the data which has been received. This

//data is stored in the data array and then printed out

peer().recv_n(data,DATA_SIZE);

ACE_OS::printf(”<< %s\n”,data);

　

// keep yourself registered with the reactor

return 0;

}

// new method which returns the handle to the reactor when it

//asks for it.

ACE_HANDLE get_handle(void) const

{

return this->peer_.get_handle();

}

//new method which returns a reference to the peer stream

ACE_SOCK_Stream &peer(void) const

{

return (ACE_SOCK_Stream &) this->peer_;

}

};

int main(int argc, char* argv[])

{

ACE_INET_Addr addr(PORT_NUM);

//create the acceptor

MyAcceptor acceptor(addr, //address to accept on

ACE_Reactor::instance()); //the reactor to use

while(1) /* Start the reactor’s event loop */

ACE_Reactor::instance()->handle_events();

}