摘要:
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来配置:
值"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,代码如下:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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\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,代码如下:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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\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服务器,执行如下命令:
8. 运行hello.exe
此时server端和client端即实现通信。