Axis2/C 基础入门

Axis2/C是一个用C语言实现的Web Service引擎。

Axis2/C基于Axis2架构 ，支持SOAP1.1 和SOAP1.2 协议，并且支持RESTful 风格的Web Service。基于Axis2/C的Web Service可以同时暴露为SOAP和RESTful风格的服务。

最近研究了一下Axis2/C，这篇文章详述了如何利用Axis2/C发布一个Web Service，并通过SOAP访问这个Web Service。

一、Axis2/C的下载和安装
1、可以从Axis2/C的官方网站下载到最新的Axis2/C发布包：Axis2/C下载

2、解压axis2c-bin-1.6.0-win32.zip，并在系统的环境变量中添加AXIS2_HOME并指向Axis2/C的解压目录，这样可以确保后续编译过程中可以找到Axis2/C的依赖项；

3、在系统环境变量中找到Path项，编辑该项，在它的最开始加入C:\VS8\Common7\IDE，并以分号分隔，以此保证编译后的客户端程序可以顺利找到依赖项；

4、在Path的结尾添加%AXIS2_HOME%\lib，确保编译器可以找到Axis2/C的依赖项；

二、构建和发布服务
5、新建CPP文件，命名为：hello_svc.c，并加入如下代码：

  1  #include  " stdafx.h "
  2  
  3  #include  < axis2_svc_skeleton.h >
  4  #include  < axutil_log_default.h >
  5  #include  < axutil_error_default.h >
  6  #include  < axutil_array_list.h >
  7  #include  < axiom_text.h >
  8  #include  < axiom_node.h >
  9  #include  < axiom_element.h >
 10  #include  < stdio.h >
 11  
 12  axiom_node_t  * axis2_hello_greet( const  axutil_env_t  * env, axiom_node_t  * node);
 13  int  AXIS2_CALL hello_free(axis2_svc_skeleton_t  * svc_skeleton,  const  axutil_env_t  * env);
 14  axiom_node_t *  AXIS2_CALL hello_invoke(axis2_svc_skeleton_t  * svc_skeleton,  const  axutil_env_t  * env, axiom_node_t  * node, axis2_msg_ctx_t  * msg_ctx);
 15  int  AXIS2_CALL hello_init(axis2_svc_skeleton_t  * svc_skeleton,  const  axutil_env_t  * env);
 16  axiom_node_t *  AXIS2_CALL hello_on_fault(axis2_svc_skeleton_t  * svc_skeli,  const  axutil_env_t  * env, axiom_node_t  * node);
 17  axiom_node_t  * build_greeting_response( const  axutil_env_t  * env, axis2_char_t  * greeting);
 18  
 19  axiom_node_t  * axis2_hello_greet( const  axutil_env_t  * env, axiom_node_t  * node)
 20  {
 21      axiom_node_t  * client_greeting_node  =  NULL;
 22      axiom_node_t  * return_node  =  NULL;
 23      AXIS2_ENV_CHECK(env, NULL);
 24       if  (node)
 25      {
 26          client_greeting_node  =  axiom_node_get_first_child(node, env);
 27           if  (client_greeting_node  &&  axiom_node_get_node_type(client_greeting_node, env)  ==  AXIOM_TEXT)
 28          {
 29              axiom_text_t  * greeting  =  (axiom_text_t  * )axiom_node_get_data_element(client_greeting_node, env);
 30               if  (greeting  &&  axiom_text_get_value(greeting , env))
 31              {
 32                   const  axis2_char_t  * greeting_str  =  axiom_text_get_value(greeting, env);
 33                  printf( " Client greeted saying \ " % s\ "  \n " , greeting_str);
 34                  return_node  =  build_greeting_response(env,  " Hello Client! " );
 35              }
 36          }
 37      }
 38       else
 39      {
 40          AXIS2_ERROR_SET(env -> error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
 41          printf( " ERROR: invalid XML in request\n " );
 42          return_node  =  build_greeting_response(env,  " Client! Who are you? " );
 43      }
 44       return  return_node;
 45  }
 46  
 47  
 48  
 49  axiom_node_t  * build_greeting_response( const  axutil_env_t  * env, axis2_char_t  * greeting)
 50  {
 51      axiom_node_t *  greeting_om_node  =  NULL;
 52      axiom_element_t  *  greeting_om_ele  =  NULL;
 53      greeting_om_ele  =  axiom_element_create(env, NULL,  " greetResponse " , NULL,  & greeting_om_node);
 54      axiom_element_set_text(greeting_om_ele, env, greeting, greeting_om_node);
 55       return  greeting_om_node;
 56  }
 57  
 58  static   const  axis2_svc_skeleton_ops_t hello_svc_skeleton_ops_var  =  {
 59      hello_init,
 60      hello_invoke,
 61      hello_on_fault,
 62      hello_free
 63  };
 64  
 65  axis2_svc_skeleton_t  * axis2_hello_create( const  axutil_env_t  * env)
 66  {
 67      axis2_svc_skeleton_t  * svc_skeleton  =  NULL;
 68      svc_skeleton  =  (axis2_svc_skeleton_t  * ) AXIS2_MALLOC(env -> allocator,  sizeof (axis2_svc_skeleton_t));
 69      svc_skeleton -> ops  =   & hello_svc_skeleton_ops_var;
 70      svc_skeleton -> func_array  =  NULL;
 71       return  svc_skeleton;
 72  }
 73  
 74  int  AXIS2_CALL hello_init(axis2_svc_skeleton_t  * svc_skeleton,  const  axutil_env_t  * env)
 75  {
 76      svc_skeleton -> func_array  =  axutil_array_list_create(env,  0 );
 77      axutil_array_list_add(svc_skeleton -> func_array, env,  " helloString " );
 78       return  AXIS2_SUCCESS;
 79  }
 80  
 81  
 82  
 83  axiom_node_t *  AXIS2_CALL hello_invoke(axis2_svc_skeleton_t  * svc_skeleton,  const  axutil_env_t  * env, axiom_node_t  * node, axis2_msg_ctx_t  * msg_ctx)
 84  {
 85       return  axis2_hello_greet(env, node);
 86  }
 87  
 88  axiom_node_t *  AXIS2_CALL hello_on_fault(axis2_svc_skeleton_t  * svc_skeli,  const  axutil_env_t  * env, axiom_node_t  * node)
 89  {
 90      axiom_node_t  * error_node  =  NULL;
 91      axiom_node_t *  text_node  =  NULL;
 92      axiom_element_t  * error_ele  =  NULL;
 93      error_ele  =  axiom_element_create(env, node,  " EchoServiceError " , NULL,
 94           & error_node);
 95      axiom_element_set_text(error_ele, env,  " Echo service failed  " ,
 96          text_node);
 97       return  error_node;
 98  }
 99  
100  
101  
102  int  AXIS2_CALL hello_free(axis2_svc_skeleton_t  * svc_skeleton,
103              const  axutil_env_t  * env)
104  {
105       if  (svc_skeleton -> func_array)
106      {
107          axutil_array_list_free(svc_skeleton -> func_array, env);
108          svc_skeleton -> func_array  =  NULL;
109      }
110  
111       if  (svc_skeleton)
112      {
113          AXIS2_FREE(env -> allocator, svc_skeleton);
114          svc_skeleton  =  NULL;
115      }
116       return  AXIS2_SUCCESS;
117  }
118  
119  AXIS2_EXPORT  int  axis2_get_instance(axis2_svc_skeleton_t  ** inst,  const  axutil_env_t  * env)
120  {
121       * inst  =  axis2_hello_create(env);
122       if  ( ! ( * inst))
123      {
124           return  AXIS2_FAILURE;
125      }
126       return  AXIS2_SUCCESS;
127  }
128  
129  
130  
131  AXIS2_EXPORT  int  axis2_remove_instance(axis2_svc_skeleton_t  * inst,  const  axutil_env_t  * env)
132  {
133      axis2_status_t status  =  AXIS2_FAILURE;
134       if  (inst)
135      {
136          status  =  AXIS2_SVC_SKELETON_FREE(inst, env);
137      }
138       return  status;
139  }
140  

6、编译上述代码，在命令行运行如下编译命令：

$ C:\VS8\VC\bin\cl.exe  / D  " WIN32 "   / D  " _WINDOWS "   / D  " _MBCS "   / D  " AXIS2_DECLARE_EXPORT "   / D  " AXIS2_SVR_MULTI_THREADED "   / w  / nologo  / I  % AXIS2_HOME% \include  / I C:\\VS8\\VC\\include  / c hello_svc.c

7、链接生成的中间对象，并产生DLL，运行命令如下：

$ C:\VS8\VC\bin\link.exe  / nologo  / LIBPATH: % AXIS2_HOME% \lib  / LIBPATH:C:\\VS8\\VC\\lib axutil.lib axiom.lib axis2_parser.lib axis2_engine.lib  / DLL  / OUT:hello.dll  * .obj

8、在 % AXIS2_HOME%\services下创建目录hello， 将步骤7产生的hello.dll拷贝到其中，并创建服务描述文件services.xml，并插入如下内容：

 1  <? xml version="1.0" encoding="utf-8" ?>
 2  < service  name ="hello" >
 3     < parameter  name ="ServiceClass"  locked ="xsd:false" > hello </ parameter >
 4     < description >
 5      Quick start guide hello service sample.
 6     </ description >
 7     < operation  name ="greet" >
 8       < parameter  name ="wsamapping" > http://ws.apache.org/axis2/c/samples/hello </ parameter >
 9     </ operation >
10  </ service >

9、启动Axis2服务器，执行如下命令：

$ axis2_http_server

三、访问服务
10、在VS中创建项目Axis2Test，并在 Axis2Test.cpp中插入这些代码：

  1  #include  " stdafx.h "
  2  
  3  #include  < stdio.h >
  4  #include  < axiom.h >
  5  #include  < axis2_util.h >
  6  #include  < axiom_soap.h >
  7  #include  < axis2_client.h >
  8  
  9  axiom_node_t  * build_om_request( const  axutil_env_t  * env);
 10  const  axis2_char_t  * process_om_response( const  axutil_env_t  * env, axiom_node_t  * node);
 11  
 12  int  _tmain( int  argc,  char **  argv)
 13  {
 14       const  axutil_env_t  * env  =  NULL;
 15       const  axis2_char_t  * address  =  NULL;
 16      axis2_endpoint_ref_t *  endpoint_ref  =  NULL;
 17      axis2_options_t  * options  =  NULL;
 18       const  axis2_char_t  * client_home  =  NULL;
 19      axis2_svc_client_t *  svc_client  =  NULL;
 20      axiom_node_t  * payload  =  NULL;
 21      axiom_node_t  * ret_node  =  NULL;
 22  
 23      env  =  axutil_env_create_all( " hello_client.log " , AXIS2_LOG_LEVEL_TRACE);
 24      options  =  axis2_options_create(env);
 25      address  =   " http://localhost:9090/axis2/services/hello " ;
 26  
 27       if  (argc  >   1 )
 28          address  =  argv[ 1 ];
 29  
 30       if  (axutil_strcmp(address,  " -h " )  ==   0 )
 31      {
 32          printf( " Usage : %s [endpoint_url]\n " , argv[ 0 ]);
 33          printf( " use -h for help\n " );
 34           return   0 ;
 35      }
 36  
 37      printf( " Using endpoint : %s\n " , address);
 38      endpoint_ref  =  axis2_endpoint_ref_create(env, address);
 39      axis2_options_set_to(options, env, endpoint_ref);
 40      axis2_options_set_action(options, env,  " http://ws.apache.org/axis2/c/samples/hello " );
 41  
 42      client_home  =   " E:\\mengli\\axis2c-bin-1.6.0-win32 " ; // AXIS2_GETENV("AXIS2C_HOME");
 43       if  ( ! client_home  &&   ! strcmp(client_home,  "" ))
 44          client_home  =   " ../.. " ;
 45  
 46      svc_client  =  axis2_svc_client_create(env, client_home);
 47       if  ( ! svc_client)
 48      {
 49          printf( " Error creating service client\n " );
 50          AXIS2_LOG_ERROR(env -> log, AXIS2_LOG_SI,  " Stub invoke FAILED: Error code: "
 51               "  %d :: %s " , env -> error -> error_number,
 52              AXIS2_ERROR_GET_MESSAGE(env -> error));
 53           return   - 1 ;
 54      }
 55  
 56      axis2_svc_client_set_options(svc_client, env, options);
 57      payload  =  build_om_request(env);
 58      ret_node  =  axis2_svc_client_send_receive(svc_client, env, payload);
 59  
 60       if  (ret_node)
 61      {
 62           const  axis2_char_t  * greeting  =  process_om_response(env, ret_node);
 63           if  (greeting)
 64              printf( " \nReceived greeting: \ " % s\ "  from service\n " , greeting);
 65  
 66          axiom_node_free_tree(ret_node, env);
 67          ret_node  =  NULL;
 68      }
 69       else
 70      {
 71          AXIS2_LOG_ERROR(env -> log, AXIS2_LOG_SI,  " Stub invoke FAILED: Error code: "
 72               "  %d :: %s " , env -> error -> error_number,
 73              AXIS2_ERROR_GET_MESSAGE(env -> error));
 74          printf( " hello client invoke FAILED!\n " );
 75      }
 76  
 77       if  (svc_client)
 78      {
 79          axis2_svc_client_free(svc_client, env);
 80          svc_client  =  NULL;
 81      }
 82  
 83       if  (env)
 84      {
 85          axutil_env_free((axutil_env_t  * ) env);
 86          env  =  NULL;
 87      }
 88  
 89       return   0 ;
 90  
 91  }
 92  
 93  axiom_node_t  *
 94  build_om_request( const  axutil_env_t  * env)
 95  {
 96      axiom_node_t *  greet_om_node  =  NULL;
 97      axiom_element_t  *  greet_om_ele  =  NULL;
 98  
 99      greet_om_ele  =  axiom_element_create(env, NULL,  " greet " , NULL,  & greet_om_node);
100      axiom_element_set_text(greet_om_ele, env,  " Hello Server! " , greet_om_node);
101  
102       return  greet_om_node;
103  }
104  
105  
106  
107  const  axis2_char_t  *
108  process_om_response( const  axutil_env_t  * env,
109                      axiom_node_t  * node)
110  {
111      axiom_node_t  * service_greeting_node  =  NULL;
112      axiom_node_t  * return_node  =  NULL;
113  
114       if  (node)
115      {
116          service_greeting_node  =  axiom_node_get_first_child(node, env);
117  
118           if  (service_greeting_node  &&
119              axiom_node_get_node_type(service_greeting_node, env)  ==  AXIOM_TEXT)
120          {
121              axiom_text_t  * greeting  =  (axiom_text_t  * )axiom_node_get_data_element(service_greeting_node, env);
122               if  (greeting  &&  axiom_text_get_value(greeting , env))
123              {
124                   return  axiom_text_get_value(greeting, env);
125              }
126          }
127      }
128  
129       return  NULL;
130  }