Axis2/c 笔记

主要参考：

http://axis.apache.org/axis2/c/core/docs/axis2c_manual.html

摘要：

Axis2是实现Web Service的一种技术框架（架构）。对于用户而言，只需要按照axis2的框架（skeleton）实现server端的逻辑（Server端的逻辑以dll的形式呈现），再实现client端的main方法进行访问即可。

 

 

当然在main函数中需要指定访问server端的逻辑，例如：

axis2_options_set_action（options, env, "http://ws.apache.org/axis2/c/samples/hello"）

其中c/samples/hello就是具体访问的逻辑了。

 

 

 

在server端，则是根据client端用户的请求，返回相应的结果，所以在server端需要配置文件来指定特定的服务，这通过service.xml来配置：

< service  name ="hello" >   < parameter  name ="ServiceClass"  locked ="xsd:false" > hello </ parameter >   < description >  Quick start guide hello service sample.  </ description >   < operation  name ="greet" /></ service >

值"ServiceClass" 和hello将作为一个映射map到发布引擎的服务，就是上面提到的dll。所以最终的结构如下：

实例：

 

 

http://axis.apache.org/axis2/c/core/docs/axis2c_manual.html 中有一个简单的实例，按照步骤实现如下：

1. 下载axis2软件包，并解压，在环境变量中添加变量AXIS2_HOME，其值为解压后的路径，例如c:\axis2c;

2. 在系统环境变量中找到Path项，编辑该项，在它的最开始加入C:\VS8\Common7\IDE，和添加%AXIS2_HOME%\lib，从而保证代码编译时可以找到相关的依赖项的路径；

3. 创建server端的逻辑，hello_svc.c，代码如下：

 

View Code

  1  #include  < axis2_svc_skeleton.h >
  2 
  3  #include  < axutil_log_default.h >
  4 
  5  #include  < axutil_error_default.h >
  6 
  7  #include  < axutil_array_list.h >
  8 
  9  #include  < axiom_text.h >
 10 
 11  #include  < axiom_node.h >
 12 
 13  #include  < axiom_element.h >
 14 
 15  #include  < stdio.h >
 16 
 17 
 18 
 19  axiom_node_t  * axis2_hello_greet( const  axutil_env_t  * env,
 20 
 21          axiom_node_t  * node);
 22 
 23 
 24 
 25  int  AXIS2_CALL
 26 
 27  hello_free(axis2_svc_skeleton_t  * svc_skeleton,
 28 
 29           const  axutil_env_t  * env);
 30 
 31 
 32 
 33  axiom_node_t *  AXIS2_CALL
 34 
 35  hello_invoke(axis2_svc_skeleton_t  * svc_skeleton,
 36 
 37           const  axutil_env_t  * env,
 38 
 39          axiom_node_t  * node,
 40 
 41          axis2_msg_ctx_t  * msg_ctx);
 42 
 43 
 44 
 45 
 46 
 47  int  AXIS2_CALL
 48 
 49  hello_init(axis2_svc_skeleton_t  * svc_skeleton,
 50 
 51           const  axutil_env_t  * env);
 52 
 53 
 54 
 55  axiom_node_t *  AXIS2_CALL
 56 
 57  hello_on_fault(axis2_svc_skeleton_t  * svc_skeli,
 58 
 59           const  axutil_env_t  * env, axiom_node_t  * node);
 60 
 61 
 62 
 63 
 64 
 65  axiom_node_t  *
 66 
 67  build_greeting_response( const  axutil_env_t  * env, 
 68 
 69          axis2_char_t  * greeting);
 70 
 71 
 72 
 73  axiom_node_t  *
 74 
 75  axis2_hello_greet( const  axutil_env_t  * env, axiom_node_t  * node)
 76 
 77  {
 78      
 79      
 80      axiom_node_t  * client_greeting_node  =  NULL;
 81 
 82      axiom_node_t  * return_node  =  NULL;
 83 
 84 
 85 
 86      AXIS2_ENV_CHECK(env, NULL);
 87 
 88 
 89      printf( " axis2_hello_greet \n " );
 90 
 91       if  (node)
 92 
 93      {
 94 
 95          client_greeting_node  =  axiom_node_get_first_child(node, env);
 96 
 97           if  (client_greeting_node  &&
 98 
 99                  axiom_node_get_node_type(client_greeting_node, env)  ==  AXIOM_TEXT)
100 
101          {
102 
103              axiom_text_t  * greeting  =  (axiom_text_t  * )axiom_node_get_data_element(client_greeting_node, env);
104 
105               if  (greeting  &&  axiom_text_get_value(greeting , env))
106 
107              {
108 
109                   const  axis2_char_t  * greeting_str  =  axiom_text_get_value(greeting, env);
110 
111                  printf( " Client greeted saying \"%s\" \n " , greeting_str);
112 
113                  return_node  =  build_greeting_response(env,  " Hello Client! " );
114 
115              }
116 
117          }
118 
119      }
120 
121       else
122 
123      {
124 
125          AXIS2_ERROR_SET(env -> error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE);
126 
127          printf( " ERROR: invalid XML in request\n " );
128 
129          return_node  =  build_greeting_response(env,  " Client! Who are you? " );
130 
131      }
132 
133 
134 
135       return  return_node;
136 
137  }
138 
139 
140 
141  axiom_node_t  *
142 
143  build_greeting_response( const  axutil_env_t  * env, axis2_char_t  * greeting)
144 
145  {
146          
147      axiom_node_t *  greeting_om_node  =  NULL;
148 
149      axiom_element_t  *  greeting_om_ele  =  NULL;
150 
151 
152 
153      greeting_om_ele  =  axiom_element_create(env, NULL,  " greetResponse " , NULL,  & greeting_om_node);
154 
155 
156 
157      axiom_element_set_text(greeting_om_ele, env, greeting, greeting_om_node);
158 
159 
160      printf( " build_greeting_response \n " );
161 
162       return  greeting_om_node;
163 
164  }
165 
166 
167 
168  static   const  axis2_svc_skeleton_ops_t hello_svc_skeleton_ops_var  =  {
169 
170 
171      hello_init,
172 
173      hello_invoke,
174 
175      hello_on_fault,
176 
177      hello_free
178 
179  };
180 
181 
182 
183  axis2_svc_skeleton_t  *
184 
185  axis2_hello_create( const  axutil_env_t  * env)
186 
187  {
188 
189      axis2_svc_skeleton_t  * svc_skeleton  =  NULL;
190 
191      svc_skeleton  =  AXIS2_MALLOC((env -> allocator),  sizeof (axis2_svc_skeleton_t));
192 
193 
194 
195      svc_skeleton -> ops  =   & hello_svc_skeleton_ops_var;
196 
197 
198 
199      svc_skeleton -> func_array  =  NULL;
200 
201      printf( " axis2_hello_create \n " );
202   
203       return  svc_skeleton;
204 
205  }
206 
207 
208 
209  int  AXIS2_CALL
210 
211  hello_init(axis2_svc_skeleton_t  * svc_skeleton,
212 
213           const  axutil_env_t  * env)
214 
215  {
216 
217  printf( " hello_init \n " );
218      svc_skeleton -> func_array  =  axutil_array_list_create(env,  0 );
219 
220      axutil_array_list_add(svc_skeleton -> func_array, env,  " helloString " );
221 
222       return  AXIS2_SUCCESS;
223 
224  }
225 
226 
227 
228  axiom_node_t *  AXIS2_CALL
229 
230  hello_invoke(axis2_svc_skeleton_t  * svc_skeleton,
231 
232           const  axutil_env_t  * env,
233 
234          axiom_node_t  * node,
235 
236          axis2_msg_ctx_t  * msg_ctx)
237 
238  {
239 
240  printf( " hello_invoke \n " );
241 
242       return  axis2_hello_greet(env, node);
243 
244  }
245 
246 
247 
248  axiom_node_t *  AXIS2_CALL
249 
250  hello_on_fault(axis2_svc_skeleton_t  * svc_skeli,
251 
252           const  axutil_env_t  * env, axiom_node_t  * node)
253 
254  {
255 
256      axiom_node_t  * error_node  =  NULL;
257 
258      axiom_node_t *  text_node  =  NULL;
259 
260      axiom_element_t  * error_ele  =  NULL;
261 
262      error_ele  =  axiom_element_create(env, node,  " EchoServiceError " , NULL,
263 
264               & error_node);
265 
266      axiom_element_set_text(error_ele, env,  " Echo service failed  " ,
267 
268              text_node);
269              
270      printf( " hello_on_fault \n " );
271 
272       return  error_node;
273 
274  }
275 
276 
277 
278  int  AXIS2_CALL
279 
280  hello_free(axis2_svc_skeleton_t  * svc_skeleton,
281 
282           const  axutil_env_t  * env)
283 
284  {
285 
286       if  (svc_skeleton -> func_array)
287 
288      {
289 
290          axutil_array_list_free(svc_skeleton -> func_array, env);
291 
292          svc_skeleton -> func_array  =  NULL;
293 
294      }
295 
296 
297 
298       if  (svc_skeleton)
299 
300      {
301 
302          AXIS2_FREE(env -> allocator, svc_skeleton);
303 
304          svc_skeleton  =  NULL;
305 
306      }
307 
308 
309      printf( " hello_free \n " );
310 
311       return  AXIS2_SUCCESS;
312 
313  }
314 
315 
316 
317 
318 
319  AXIS2_EXPORT  int
320 
321  axis2_get_instance(axis2_svc_skeleton_t  ** inst,
322 
323           const  axutil_env_t  * env)
324 
325  {
326 
327       * inst  =  axis2_hello_create(env);
328 
329       if  ( ! ( * inst))
330 
331      {
332 
333           return  AXIS2_FAILURE;
334 
335      }
336 
337 
338 
339      printf( " axis2_get_instance \n " );
340       return  AXIS2_SUCCESS;
341 
342  }
343 
344 
345 
346  AXIS2_EXPORT  int
347 
348  axis2_remove_instance(axis2_svc_skeleton_t  * inst,
349 
350           const  axutil_env_t  * env)
351 
352  {
353 
354      axis2_status_t status  =  AXIS2_FAILURE;
355 
356       if  (inst)
357 
358      {
359 
360          status  =  AXIS2_SVC_SKELETON_FREE(inst, env);
361 
362      }
363      
364      printf( " axis2_remove_instance \n " );
365 
366       return  status;
367 
368  }

 

　　4. 编译连接如下：

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

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

 从而生成hello.dll，将这个dll复制到C:\axis2c\services\hello文件夹下，作为逻辑。同时创建上面提到的services.xml，也位于这个文件夹下。

5。创建client端的main方法，文件hello.c，代码如下：

 

View Code

  1  #include  < stdio.h >
  2 
  3  #include  < axiom.h >
  4 
  5  #include  < axis2_util.h >
  6 
  7  #include  < axiom_soap.h >
  8 
  9  #include  < axis2_client.h >
 10 
 11 
 12 
 13  axiom_node_t  *
 14 
 15  build_om_request( const  axutil_env_t  * env);
 16 
 17 
 18 
 19  const  axis2_char_t  *
 20 
 21  process_om_response( const  axutil_env_t  * env,
 22 
 23          axiom_node_t  * node);
 24 
 25 
 26 
 27  int  main( int  argc,  char **  argv)
 28 
 29  {
 30 
 31       const  axutil_env_t  * env  =  NULL;
 32 
 33       const  axis2_char_t  * address  =  NULL;
 34 
 35      axis2_endpoint_ref_t *  endpoint_ref  =  NULL;
 36 
 37      axis2_options_t  * options  =  NULL;
 38 
 39       const  axis2_char_t  * client_home  =  NULL;
 40 
 41      axis2_svc_client_t *  svc_client  =  NULL;
 42 
 43      axiom_node_t  * payload  =  NULL;
 44 
 45      axiom_node_t  * ret_node  =  NULL;
 46 
 47 
 48 
 49      env  =  axutil_env_create_all( " hello_client.log " , AXIS2_LOG_LEVEL_TRACE);
 50 
 51 
 52 
 53      options  =  axis2_options_create(env);
 54 
 55 
 56 
 57      address  =   " http://localhost:9090/axis2/services/hello " ;
 58 
 59       if  (argc  >   1 )
 60 
 61          address  =  argv[ 1 ];
 62 
 63       if  (axutil_strcmp(address,  " -h " )  ==   0 )
 64 
 65      {
 66 
 67          printf( " Usage : %s [endpoint_url]\n " , argv[ 0 ]);
 68 
 69          printf( " use -h for help\n " );
 70 
 71           return   0 ;
 72 
 73      }
 74 
 75      printf( " Using endpoint : %s\n " , address);
 76 
 77      endpoint_ref  =  axis2_endpoint_ref_create(env, address);
 78 
 79      axis2_options_set_to(options, env, endpoint_ref);
 80 
 81 
 82 
 83      client_home  =  AXIS2_GETENV( " AXIS2C_HOME " );
 84 
 85       if  ( ! client_home  &&   ! strcmp(client_home,  "" ))
 86 
 87          client_home  =   " ../.. " ;
 88 
 89 
 90 
 91      svc_client  =  axis2_svc_client_create(env, client_home);
 92 
 93       if  ( ! svc_client)
 94 
 95      {
 96 
 97          printf( " Error creating service client\n " );
 98 
 99          AXIS2_LOG_ERROR(env -> log, AXIS2_LOG_SI,  " Stub invoke FAILED: Error code: "
100 
101                   "  %d :: %s " , env -> error -> error_number,
102 
103                  AXIS2_ERROR_GET_MESSAGE(env -> error));
104 
105           return   - 1 ;
106 
107      }
108 
109 
110 
111      axis2_svc_client_set_options(svc_client, env, options);
112 
113 
114 
115      payload  =  build_om_request(env);
116 
117 
118 
119      ret_node  =  axis2_svc_client_send_receive(svc_client, env, payload);
120 
121 
122 
123       if  (ret_node)
124 
125      {
126 
127           const  axis2_char_t  * greeting  =  process_om_response(env, ret_node);
128 
129           if  (greeting)
130 
131              printf( " \nReceived greeting: \"%s\" from service\n " , greeting);
132 
133 
134 
135          axiom_node_free_tree(ret_node, env);
136 
137          ret_node  =  NULL;
138 
139      }
140 
141       else
142 
143      {
144 
145          AXIS2_LOG_ERROR(env -> log, AXIS2_LOG_SI,  " Stub invoke FAILED: Error code: "
146 
147                   "  %d :: %s " , env -> error -> error_number,
148 
149                  AXIS2_ERROR_GET_MESSAGE(env -> error));
150 
151          printf( " hello client invoke FAILED!\n " );
152 
153      }
154 
155 
156 
157       if  (svc_client)
158 
159      {
160 
161          axis2_svc_client_free(svc_client, env);
162 
163          svc_client  =  NULL;
164 
165      }
166 
167 
168 
169       if  (env)
170 
171      {
172 
173          axutil_env_free((axutil_env_t  * ) env);
174 
175          env  =  NULL;
176 
177      }
178 
179 
180 
181       return   0 ;
182 
183  }
184 
185 
186 
187  axiom_node_t  *
188 
189  build_om_request( const  axutil_env_t  * env)
190 
191  {
192 
193      axiom_node_t *  greet_om_node  =  NULL;
194 
195      axiom_element_t  *  greet_om_ele  =  NULL;
196 
197 
198 
199      greet_om_ele  =  axiom_element_create(env, NULL,  " greet " , NULL,  & greet_om_node);
200 
201      axiom_element_set_text(greet_om_ele, env,  " Hello Server! " , greet_om_node);
202 
203 
204 
205       return  greet_om_node;
206 
207  }
208 
209 
210 
211  const  axis2_char_t  *
212 
213  process_om_response( const  axutil_env_t  * env,
214 
215          axiom_node_t  * node)
216 
217  {
218 
219      axiom_node_t  * service_greeting_node  =  NULL;
220 
221      axiom_node_t  * return_node  =  NULL;
222 
223 
224 
225       if  (node)
226 
227      {
228 
229          service_greeting_node  =  axiom_node_get_first_child(node, env);
230 
231           if  (service_greeting_node  &&
232 
233                  axiom_node_get_node_type(service_greeting_node, env)  ==  AXIOM_TEXT)
234 
235          {
236 
237              axiom_text_t  * greeting  =  (axiom_text_t  * )axiom_node_get_data_element(service_greeting_node, env);
238 
239               if  (greeting  &&  axiom_text_get_value(greeting , env))
240 
241              {
242 
243                   return  axiom_text_get_value(greeting, env);
244 
245              }
246 
247          }
248 
249      }
250 
251       return  NULL;
252 
253  }

 6. 编译连接如下：

C:\VS8\VC\bin\cl.exe  / nologo  / D  " WIN32 "   / D  " _WINDOWS "   / D  " _MBCS "   / I  % AXIS2C_HOME % \\include  / I C:\\VS8\\VC\\include  / I C:\\VS8\\VC\\PlatformSDK\\Include  / c hello.c

C:\VS8\VC\bin\link.exe  / LIBPATH: % AXIS2C_HOME % \lib axutil.lib axiom.lib axis2_parser.lib axis2_engine.lib  / LIBPATH:C:\VS8\VC\lib uuid.lib   / OUT:hello.exe  * .obj

 生成可执行程序hello.exe

 7. 启动Axis2服务器，执行如下命令：

C:\axis2c\bin\axis2_http_server.exe

 8. 运行hello.exe

 此时server端和client端即实现通信。

 

 

 

转载于:https://www.cnblogs.com/luweiseu/archive/2011/07/05/2098737.html