Axis2/C 基础入门

最新推荐文章于 2024-08-07 09:14:53 发布

iteye_7457

最新推荐文章于 2024-08-07 09:14:53 发布

阅读量574

点赞数

文章标签： c/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 }