这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

				// server.cpp,v 1.6 2002/01/29 20:21:07 okellogg Exp
				
				#include "Process_Factory.h"
				#include "Server_Task.h"
				#include "ace/Get_Opt.h"
				
				ACE_RCSID(Client_Leaks, server, "server.cpp,v 1.6 2002/01/29 20:21:07 okellogg Exp")
				
				const char *ior_output_file = "test.ior";
				
				int
				parse_args (int argc, char *argv[])
				{
				  ACE_Get_Opt get_opts (argc, argv, "o:");
				  int c;
				
				  while ((c = get_opts ()) != -1)
				    switch (c)
				      {
				      case 'o':
				        ior_output_file = get_opts.opt_arg ();
				        break;
				      case '?':
				      default:
				        ACE_ERROR_RETURN ((LM_ERROR,
				                           "usage:  %s "
				                           "-o "
				                           "\n",
				                           argv [0]),
				                          -1);
				      }
				  // Indicates sucessful parsing of the command line
				  return 0;
				}
				
				int
				main (int argc, char *argv[])
				{
				  ACE_TRY_NEW_ENV
				    {
				      CORBA::ORB_var orb =
				        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      CORBA::Object_var poa_object =
				        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      PortableServer::POA_var root_poa =
				        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      if (CORBA::is_nil (root_poa.in ()))
				        ACE_ERROR_RETURN ((LM_ERROR,
				                           " (%P|%t) Panic: nil RootPOA\n"),
				                          1);
				
				      PortableServer::POAManager_var poa_manager =
				        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      if (parse_args (argc, argv) != 0)
				        return 1;
				
				      Process_Factory *process_factory_impl;
				      ACE_NEW_RETURN (process_factory_impl,
				                      Process_Factory (orb.in ()),
				                      1);
				      PortableServer::ServantBase_var owner_transfer(process_factory_impl);
				
				      Test::Process_Factory_var process =
				        process_factory_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      CORBA::String_var ior =
				        orb->object_to_string (process.in () ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      // If the ior_output_file exists, output the ior to it
				      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
				      if (output_file == 0)
				        ACE_ERROR_RETURN ((LM_ERROR,
				                           "Cannot open output file for writing IOR: %s",
				                           ior_output_file),
				                              1);
				      ACE_OS::fprintf (output_file, "%s", ior.in ());
				      ACE_OS::fclose (output_file);
				
				      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      Server_Task server_task (orb.in (),
				                               ACE_Thread_Manager::instance ());
				
				      if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 8, 1) == -1)
				        {
				          ACE_ERROR ((LM_ERROR, "Error activating server task\n"));
				        }
				
				      ACE_Thread_Manager::instance ()->wait ();
				
				      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
				
				      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				
				      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
				      ACE_TRY_CHECK;
				    }
				  ACE_CATCHANY
				    {
				      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
				                           "Exception caught:");
				      return 1;
				    }
				  ACE_ENDTRY;
				
				  return 0;
				}