Android经过ksoap2这个框架调用webservice大讲堂

昨天有人问我Android怎么链接mysql数据库，和对数据库的操做呀，我想把，给他说说json通讯，但是他并不知道怎么弄，哎算了吧，直接叫他用ksoap吧，给他说了大半天，好多零碎的知识，看来仍是有必要把这些东西整合起来，一方面本身有时候也看，另外一方面固然是能帮助没有作个的小伙伴，其实东西不是不少，就是讲的有点详细，不怕多，就怕不仔细，
WebServices简介
Web services是一种部署在Web上的对象或者组件，可以经过Internet进行调用的应用程序。Web services 创建在以XML为主的开放的web规范技术基础上，其业务逻辑对调用者来讲是透明的。

Webservices调用须要注意的问题(附案例)
接下来咱们结合一个案例来理解整个调用过程，针对当时开发时遇到的问题，进行详细说明。
附：表达能力有限，有不少东西讲的不是很清楚，请结合附带案例看此文档，但愿能帮到你
准备工做
相关jar包导入
新建android项目，将ksoap2-android-assembly-3.0.0-jar-with-dependencies.jar放在android项目的lib目录下，检查jar包是否以下图所示：

相关权限添加
既然是访问网络操做，就须要添加访问网络的权限：
对AndroidManifest.xml文件进行修改，添加网络权限
，
调用webService服务步骤
第一步，指定WebServices的命名空间和调用的方法名
SoapObjectrpc = new SoapObject(NameSpace,methodName);
第二步，设置须要调用的webServices接口须要传入的参数
rpc.addProperty(proPertyName,proPertyValue);
第三步，生成调用WebServices方法的SOAP请求信息，并制定SOAP的版本
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER10);
envelope.bodyOUt = rpc;
第四步，生成调用WebServices方法的HttpTransportSE实体对象
HttpTransportSE transport = new HttpTransportSE(ServiceURL);
第五步，调用call方法请求服务
Transport.call(soapAction,envelope);
第六步，获取服务端返回的数据
SoapObject object = (SoapObject)envelope.bodyIn;
第七步，解析返回的soapObject并获取须要的数据结果
String result = object.getProPerty(0).toString();
对调用过程的分析
注意1：第一步、第四步、第五步中，涉及到调用WebServices以前须要弄清楚”NameSpace”、”methodName”、”serviceURL”、”soapAction”。这些值须要从wsdl文档中寻找，若是想对wsdl文档深刻学习，请参考wsdl学习文档，本文档只说明如何从wsdl文档中找到相应的值。
将服务端提供的url地址浏览器地址栏能够看到以下界面:

经过连接访问wsdl文档，能够看到当前wsdl文档应用的所得有命名空间，内容界面以下：
在此文档中，咱们也能够找到咱们须要的四个重要的属性值：
命名空间：找到wsdl:definitions节点，即wsdl的根节点，找到属性targetNamespace的值，即为咱们所需的命名空间nameSpace的值，如图：


方法名和SoapAction：找到wsdl:operation节点，其属性name的值即为咱们所需的方法名methodName的值，其子节点soap:operation的属性SoapAction的值即为当前咱们所需方法所对应的soapAction的值，如图：
至此，调用webService服务所需的最基本的四个属性值获取完成。但调用的过程当中必定要保证methodName与soapAction的一一对应关系。
注意2：第二步中，涉及到设置参数。经过wsdl文件中wsdl:types节点的子节点xsd:import
经过第一个URL获取到当前服务的全部方法、每一个方法的全部参数及参数类型

经过第二个URL获取到当前服务全部能直接传递的数据类型，即基本数据类型

经过第三个URL获取到当前服务全部自定义类型的参数、参数的全部属性及属性类型

经过第一个URL访问到以下界面：

针对参数类型，如何判断参数是否是自定义参数类型呢？能够经过第二个URL跳转查看服务描述的全部基本数据类型，以下图：

若没有，经过第三个URL跳转查看服务描述的全部自定义类型，一一对应的关系，若是没有在当前连接里找到你所要了解的数据类型，那么这种数据类型即为复杂类型，或称自定义类型。须要对自定义类型的属性加以进一步了解，以下图：
若没有，能够询问服务端负责人员
自定义数据类型参数问题
针对这种自定义类型的参数，经过第二步中设置参数是达不到咱们想要的效果的，服务端返回的信息为”服务器内部错误”等。那么这种状况咱们该怎么解决呢？
下面拿上述TransferParams讲解一下：
第一步、在本地新建TransferParams.java文件，实现KvmSerializable序列化接口。
第二步、将上图中TransferParams参数包含的全部属性按顺序声明，注意：必定要按顺序
第三步、实现getProperty(int arg0)、getPropertyCount()、getPropertyInfo(int arg0,Hashtable arg1,PropertyInfo arg2)、setProperty(int arg0,Object arg1)方法。
getProperty(int arg0) 经过索引获取指定属性
getPropertyCount() 获取属性集合的大小
getPropertyInfo(int arg0,Hashtable arg1,PropertyInfo arg2)
获取指定索引的属性的名称和类型，注意：方法中第一件事是为参数设置命名空间
setProperty(int arg0,Object arg1) 为指定的属性赋值
第四步、在调用过程当中，添加本地数据类型与服务端数据类型的映射，经过addMapping()方法在调用webService服务的HttpTransportSE对象调用call()方法以前。
addMapping()方法有三个参数，分别是服务端的引用url、参数名和本地对应的类型。代码以下：envelope.addMapping(soapMapping, “TransferParams”, TransferParams.class);
三个参数可经过自定义参数描述文件中xs:schema节点的targetNamespace属性值、xs:complexType节点的name属性值获取到SoapMapping和TransferParams两个值。
这样自定义类型的参数的问题也差很少能解决了。
带有自定义类型属性的自定义类型参数
可是此刻就又有问题了，你应该发现了此时自定义类型参数的全部属性都是基本数据类型，那若是此参数的某个属性也是自定义类型的，该怎么解决呢？解决方法与上述自定义类型的解决方法类似，就是新建java文件实现kvmSerializable序列化接口来描述自定义类型的属性，而后以普通属性的形式在自定义类型参数中声明。
自定义类型参数集合
到这里，自定义类型的参数问题已经解决了一半，剩下的一半是自定义类型参数集合。若是拥有自定义类型属性的自定义参数你理解了，那么这剩下的一半自定义类型参数集合就很容易了。这里你能够把集合想象成一个有且只有一个属性的参数，而此属性也为自定类型的。只是不一样的是你在新建集合的java文件时，须要继承Vector，这里的E指的是集合中包含的参数类型。固然参数类型的映射仍须要添加。

最后，针对上面的资源用一个完整的案例帮助你们分析一下，因此请容我再啰嗦一遍
准备工做
服务地址 http://10.0.1.223:9100/KdtService/
Ksoap2-android.Jar包 下载地址:http://pan.baidu.com/s/1CE754
一、 新建android项目，导入jar包，添加权限
二、 修改activity_main.xml文件，添加三个按钮分别用于测试无参(基本数据类型)webServices服务调用、自定义参数webServices服务调用、自定义参数集合webServices服务调用和一个用于显示结果的显示框，代码以下：
package com.example.webservicetest;

import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;

public class WebServiceOp {
//命名空间
private static final String NAME_SPACE = "http://tempuri.org/";
//服务地址
private static final String URL = "http://10.0.1.223:9100/KdtService/basic";
//操做方法的名称
private static String methodName = "";
private static String soapMapping = "http://schemas.datacontract.org/2004/07/WebServiceManager";
private static LinkedHashMap<String,Object>paramMap;
private static TransferParamstran;
private static int flag = 1;
/**
* 公用方法
* @parammethodname方法名称
* @paramparamMap 参数集合
* @return
* @throws IOException
*/
public static SoapObjectLoadResult(String methodname,Map<String,Object>paramMap) throws IOException{
//建立soap对象，传入所需调用的webService的命名空间和webService方法名
SoapObjectsoapObject = new SoapObject(NAME_SPACE, methodname);
//建立SoapSerializationEnvelope对象，传入所需版本
SoapSerializationEnvelope envelope
= new SoapSerializationEnvelope(SoapEnvelope.VER11);
//建立HttpTransportSE对象，该对象用于调用webService操做
HttpTransportSE trans = new HttpTransportSE(URL,20000);
//判断参数集合是否为空
if(paramMap != null)
{
//将map中的参数放入迭代器中
Iterator<Entry<String, Object>>iter = paramMap.entrySet().iterator();
//遍历迭代器，为soap对象设置参数
while(iter.hasNext()){
Map.Entry<String, Object> me = iter.next();
soapObject.addProperty(me.getKey(),"".equals(me.getValue())?null:me.getValue());
}
//服务器端自定义类型的映射
switch(flag)
{
case 0:
break;
case 1:
envelope.addMapping(soapMapping, "TransferParams", TransferParams.class);
break;
case 2:
envelope.addMapping(soapMapping, "TransferParams", TransferParams.class);
envelope.addMapping(soapMapping, "ParamEnt", ParamEnt.class);
envelope.addMapping(soapMapping, "ArrayOfParamEnt", ArrayOfPEnt.class);
break;
case 3:
envelope.addMapping(soapMapping, "TransferParams", TransferParams.class);
envelope.addMapping(soapMapping, "ScanData", ScanData.class);
envelope.addMapping(soapMapping, "ArrayOfScanData", ArrayOfScanData.class);
break;

default:
break;
}

}
//建立的SoapObject对象设为SoapSerializationEnvelope的传出SOAP消息体
envelope.bodyOut = soapObject;
envelope.setOutputSoapObject(soapObject);
//设置兼容.net服务器端
envelope.dotNet = true;
//使用调试功能
trans.debug = true;

try {
//调用操做对象call方法，将SoapSerializationEnvelope做为参数调用远程webService
trans.call(NAME_SPACE + "IKdtService/" + methodname, envelope);
System.out.println(trans.requestDump);
//调用完成，访问SoapSerializationEnvelope对象的bodyIn属性，该属性返回一个SoapObject对象，该对象表明webService的返回信息
SoapObject result = (SoapObject) envelope.bodyIn;
//打印Log日志信息
return result;
} catch (XmlPullParserException e) {
e.printStackTrace();
return null;
}
}
//无参调用
public static SoapObjectserverTime() throws IOException
{
methodName = "ServerTime";
flag = 0;
return LoadResult(methodName, null);
}
//自定义类型参数调用
public static SoapObject register() throws IOException
{ //设置须要调用的服务器接口方法的名称
methodName = "Register";

tran = new TransferParams();
tran.setCompress(true);
tran.setDBType(0);
tran.setDefaultLogic(true);
tran.setEnterpriseID("Thinta");
tran.setFileType(0);
tran.setPDAID("1000000");
tran.setStationID("900001");
//将自定义类型以参数形式放入map集合中
paramMap = new LinkedHashMap<String, Object>();
paramMap.put("param", tran);
flag = 1;
return LoadResult(methodName, paramMap);
}
//含有自定义类型参数集合的调用
public static SoapObjectdownLoad() throws IOException
{
methodName = "Download";

tran = new TransferParams();
tran.setCompress(true);
tran.setDBType(0);
tran.setDefaultLogic(true);
tran.setEnterpriseID("Thinta");
tran.setFileType(0);
tran.setPDAID("1000000");
tran.setStationID("900001");

ParamEnt p1= new ParamEnt();
p1.setTableName("SiteInfo");
ParamEnt p2 = new ParamEnt();
p2.setTableName("Employee");

ArrayOfPEntaope = new ArrayOfPEnt();
aope.add(p1);
aope.add(p2);

paramMap = new LinkedHashMap<String, Object>();
paramMap.put("param", tran);
paramMap.put("list", aope);
flag = 2;
return LoadResult(methodName, paramMap);
}
}
1

对于这个类，须要啰嗦几句。
主要方法是LoadResult(String methodName, Map

package com.example.webservicetest;

import java.util.Hashtable;

import org.ksoap2.serialization.KvmSerializable;
import org.ksoap2.serialization.PropertyInfo;

public class TransferParams implements KvmSerializable{
private boolean Compress;
private intDBType;
private booleanDefaultLogic;
private String EnterpriseID;
private intFileType;
private String MD5;
private String PDAID;
private String StationID;
private String Version;

@Override
public Object getProperty(int arg0) {
switch (arg0) {
case 0:
return Compress;
case 1:
return DBType;
case 2:
return DefaultLogic;
case 3:
return EnterpriseID;
case 4:
return FileType;
case 5:
return MD5;
case 6:
return PDAID;
case 7:
return StationID;
case 8:
return Version;
default:
return null;
}
}

@Override
public intgetPropertyCount() {
return 9;//参数的个数
}

@Override
public void getPropertyInfo(int arg0, Hashtable arg1, PropertyInfo arg2) {
//这个很重要
arg2.namespace="http://schemas.datacontract.org/2004/07/WebServiceManager"; switch (arg0) {
case 0:
arg2.type=PropertyInfo.BOOLEAN_CLASS;
arg2.name="Compress";
break;
case 1:
arg2.type=PropertyInfo.INTEGER_CLASS;
arg2.name="DBType";
break;
case 2:
arg2.type=PropertyInfo.BOOLEAN_CLASS;
arg2.name="DefaultLogic";
break;
case 3:
arg2.type=PropertyInfo.STRING_CLASS;
arg2.name="EnterpriseID";
break;
case 4:
arg2.type=PropertyInfo.INTEGER_CLASS;
arg2.name="FileType";
break;
case 5:
arg2.type=PropertyInfo.STRING_CLASS;
arg2.name="MD5";
break;
case 6:
arg2.type=PropertyInfo.STRING_CLASS;
arg2.name="PDAID";
break;
case 7:
arg2.type=PropertyInfo.STRING_CLASS;
arg2.name="StationID";
break;
case 8:
arg2.type=PropertyInfo.STRING_CLASS;
arg2.name="Version";
break;
default:
break;
}
}

@Override
public void setProperty(int arg0, Object arg1) {
switch (arg0) {
case 0:
Compress = Boolean.getBoolean(arg1.toString());
break;
case 1:
DBType = Integer.valueOf(arg1.toString());
break;
case 2:
DefaultLogic = Boolean.getBoolean(arg1.toString());
break;
case 3:
EnterpriseID = arg1.toString();
break;
case 4:
FileType = Integer.valueOf(arg1.toString());
break;
case 5:
MD5 = arg1.toString();
break;
case 6:
PDAID = arg1.toString();
break;
case 7:
StationID = arg1.toString();
break;
case 8:
Version = arg1.toString();
break;
default:
break;
}
}

public booleanisCompress() {
return Compress;
}

public void setCompress(boolean compress) {
Compress = compress;
}

public intgetDBType() {
return DBType;
}

public void setDBType(intdBType) {
DBType = dBType;
}

public booleanisDefaultLogic() {
return DefaultLogic;
}

public void setDefaultLogic(booleandefaultLogic) {
DefaultLogic = defaultLogic;
}

public String getEnterpriseID() {
return EnterpriseID;
}

public void setEnterpriseID(String enterpriseID) {
EnterpriseID = enterpriseID;
}

public intgetFileType() {
return FileType;
}

public void setFileType(intfileType) {
FileType = fileType;
}

public String getMD5() {
return MD5;
}

public void setMD5(String mD5) {
MD5 = mD5;
}

public String getPDAID() {
return PDAID;
}

public void setPDAID(String pDAID) {
PDAID = pDAID;
}

public String getStationID() {
return StationID;
}

public void setStationID(String stationID) {
StationID = stationID;
}

public String getVersion() {
return Version;
}

public void setVersion(String version) {
Version = version;
}

}
1

201
202
此文件中除了属性的名称须要同wsdl文件中的一致，getProperty()、getPropertyInfo()、setProperty()方法中属性的顺序须要注意意外，特别须要注意就是上边红色代码部分，一个是getCount()方法的返回值，一个是getPropertyInfo()方法第三个参数的命名空间的设置。返回值是随着属性的改变而改变的，这点必定要注意，若是当前返回值小于属性的总数，调用的过程当中可能会出现数组越界的异常；命名空间也是与wsdl文件中的值对应的，若是命名空间匹配出错，会影响服务器端的处理及返回值，拿本例来说，若是把命名空间赋值的代码注释掉，调用服务返回的结果是ERROR，而命名空间赋值匹配正确的状况下，调用服务返回的结果则是PAD IS REGISTEDS，因此必定要注意命名空间的赋值。除了命名空间的匹配外，咱们还须要进行服务端与客户端对自定义类型的映射，就是那段addMapping添加映射的代码，第一个参数是服务端自定义类型参数所处的命名空间对应的引用，第二个参数是此类型参数在服务端的参数名称，第三个参数是客户端(即本地)该自定义类型的参数所对应的类型。
包括自定义类型、类型映射工做作完并都保证正确以后，再进行服务调用操做，应该就不会出现错误了。
自定义类型参数集合(downLoad)在此处表明含有自定义属性的自定义参数和自定义参数集合的调用服务操做，这里的参数为ArrayOfPEnt类型，由于它表明的是ParamEnt类型的集合，针对这种自定义类型，咱们一样须要映射，既然要映射，就须要服务器端和客户端的各自的类型，而此时只有服务器端对这个类型进行了定义，客户端并无对这个类型进行定义，因此接下来的第一件事就是定义ArrayOfPEnt类型。具体做法以下：
五、 新建ParamEnt.java文件，作法同第四步相同，这里重点说一下ArrayOfPEnt.java文件，实现KvmSerializable接口并继承Vector容器类，以便起到集合的做用。代码以下：

package com.example.webservicetest;

import java.util.Hashtable;
import java.util.Vector;

import org.ksoap2.serialization.KvmSerializable;
import org.ksoap2.serialization.PropertyInfo;

public class ArrayOfPEnt extends Vector<ParamEnt>
implements
KvmSerializable
{

@Override
public Object getProperty(int arg0)
{
return this.get(arg0);
}

@Override
public intgetPropertyCount()
{
return this.size();
}

@Override
public void getPropertyInfo(int arg0, Hashtable arg1, PropertyInfo arg2)
{
// arg2.namespace = "http://schemas.datacontract.org/2004/07/WebServiceManager";
arg2.name = "ParamEnt";
arg2.type = ParamEnt.class;
}

@Override
public void setProperty(int arg0, Object arg1)
{
this.add((ParamEnt) arg1);
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
须要注意的地方同第四步，此处再也不赘述。
六、 编写MainActivity.java文件，以下：

package com.example.webservicetest;

import java.io.IOException;

import org.ksoap2.serialization.SoapObject;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.TextureView;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity implements OnClickListener{
Button b1,b2,b3;
TextView t;
private SoapObjectsoapObject = new SoapObject();
private String resultStr = "";
private Handler mHandler = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

t = (TextView) findViewById(R.id.textView);
b1 = (Button) findViewById(R.id.simple);
b2 = (Button) findViewById(R.id.simplecom);
b3 = (Button) findViewById(R.id.comlist);

b1.setOnClickListener(this);
b2.setOnClickListener(this);
b3.setOnClickListener(this);

mHandler = new Handler()
{
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0x11:
t.setText(resultStr);
break;
case 0x12:
t.setText(resultStr);
break;
case 0x13:
t.setText(resultStr);
break;

default:
break;
}
}
};
}

@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.simple:
new Thread(){
public void run() {
try {
soapObject = WebServiceOp.serverTime();
resultStr = "请求无参的服务调用-->结果为:" + soapObject.toString();

Message msg = new Message();
msg.what = 0x11;
mHandler.sendMessage(msg);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
};
}.start();
break;
case R.id.simplecom:
new Thread()
{
public void run() {
try {
soapObject = WebServiceOp.register();
resultStr = "请求自定义参数的服务调用-->结果为:" + soapObject.toString();

Message msg = new Message();
msg.what = 0x12;
mHandler.sendMessage(msg);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
};
}.start();
break;
case R.id.comlist:
new Thread()
{
public void run() {
try {
soapObject = WebServiceOp.downLoad();
resultStr = "请求自定义参数集合的服务调用-->结果为:" + soapObject.toString();

Message msg = new Message();
msg.what = 0x13;
mHandler.sendMessage(msg);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
};
}.start();
break;
default:
break;
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
上面的方法你如果以为太杂太乱的话，我有写了一个高度集中的方法，面对任何参数任何类型的，简单数据类型，自定义对象。。。看看吧

package com.agbc.webservice;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.ksoap2.SoapEnvelope;
import org.ksoap2.SoapFault;
import org.ksoap2.serialization.MarshalBase64;
import org.ksoap2.serialization.MarshalDate;
import org.ksoap2.serialization.MarshalFloat;
import org.ksoap2.serialization.PropertyInfo;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;

import sun.management.resources.agent;

import com.agbc.Api.AgbcApi;
import com.agbc.entity.TUser;

import android.content.Context;
import android.graphics.Bitmap;
import android.os.Handler;
import android.os.Message;
import android.os.Messenger;
import android.support.v4.util.LruCache;
import android.util.Log;
/**
* 请求webservice封装类
* 2016/4/10 进行优化，添加三级缓存技术
* @author double 江
*
*/
public class WebServiceBase {
public static final int SUCCSEE = 0;
public static final int FAIL = 1;
private SoapObject request;
public WebServiceBase() {
}
public WebServiceBase(Context context,Handler handler){
Executors.newFixedThreadPool(5);

}
/**
* 经过传递简单数据类型参数，
* 服务端方法名称获取范围webservice的数据，
* 倒数第二个参数是服务端的方法名，必须与服务端一致。
* 最后一个参数是服务端url，
*
* @param arg 参数列表Object类型的
* @return 返回SoapObject类型的原始数据
*/
public SoapObject getBaseSimpleData(Object...arg){

final String methodName=arg[(arg.length-2)].toString();
final String soapAction=AgbcApi.NAMESPACE+methodName;
request = new SoapObject(AgbcApi.NAMESPACE, methodName);
for (int i = 0; i < arg.length-2; i++) {
request.addProperty("arg"+i, arg[i]);
Log.i("arg"+i, arg[i].toString());
}
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
(new MarshalBase64()).register(envelope);
envelope.bodyOut = request;
envelope.dotNet=false;
envelope.setOutputSoapObject(request);
HttpTransportSE ht = new HttpTransportSE(arg[arg.length-1].toString(),10000);
ht.debug=true;
try {
ht.call(soapAction, envelope);
if(envelope.bodyIn instanceof SoapFault){
String str = ((SoapFault) envelope.bodyIn).faultstring;//返回的是空节点
Log.i("返回错误的数据", str);
}
else {
request=(SoapObject) envelope.bodyIn;
Log.i("得到原始数据", request.toString());
}
} catch (IOException e) {
e.printStackTrace();
} catch (XmlPullParserException e) {
e.printStackTrace();
}
return request;
};

/**
* 经过传递简单数据类型参数，
* 服务端方法名称获取范围webservice的数据，
* 倒数第三个位回调标记 int类型的
* 倒数第二个参数是服务端的方法名，必须与服务端一致。
* 最后一个参数是服务端url，
* @param arg 参数列表Object类型的
*
*/
public SoapObject getBaseSimpleDataByNamespace(Object...arg){

final String methodName=arg[(arg.length-2)].toString();
final String soapAction=AgbcApi.NAMESPACETWO+methodName;
request = new SoapObject(AgbcApi.NAMESPACETWO, methodName);
for (int i = 0; i < arg.length-2; i++) {
request.addProperty("arg"+i, arg[i]);
Log.i("arg"+i, arg[i].toString());
}
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
(new MarshalBase64()).register(envelope);
envelope.bodyOut = request;
envelope.dotNet=false;
envelope.setOutputSoapObject(request);
HttpTransportSE ht = new HttpTransportSE(arg[arg.length-1].toString(),10000);
ht.debug=true;
try {
ht.call(soapAction, envelope);
if(envelope.bodyIn instanceof SoapFault){
String str = ((SoapFault) envelope.bodyIn).faultstring;//返回的是空节点
Log.i("返回错误的数据", str);
}
else {
request=(SoapObject) envelope.bodyIn;
Log.i("得到原始数据", request.toString());
}
} catch (IOException e) {
e.printStackTrace();
} catch (XmlPullParserException e) {
e.printStackTrace();
}
return request;
};
// public void getBaseSimpleData1(final Object...arg){
// executorService.execute(new Runnable() {
// @Override
// public void run() {
// final String methodName=arg[(arg.length-2)].toString();
// final String soapAction=AgbcApi.NAMESPACE+methodName;
// request = new SoapObject(AgbcApi.NAMESPACE, methodName);
// for (int i = 0; i < arg.length-3; i++) {
// request.addProperty("arg"+i, arg[i]);
// Log.i("arg"+i, arg[i].toString());
// }
// SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
// (new MarshalBase64()).register(envelope);
// envelope.bodyOut = request;
// envelope.dotNet=false;
// envelope.setOutputSoapObject(request);
// HttpTransportSE ht = new HttpTransportSE(arg[arg.length-1].toString(),10000);
// ht.debug=true;
// try {
// ht.call(soapAction, envelope);
// if(envelope.bodyIn instanceof SoapFault){
// String str = ((SoapFault) envelope.bodyIn).faultstring;//返回的是空节点
// Log.i("返回错误的数据", str);
// Message message=Message.obtain();
// message.what=FAIL;
// handler.sendMessage(message);
// }
// else {
// request=(SoapObject) envelope.bodyIn;
// Log.i("得到原始数据", request.toString());
// message=Message.obtain();
// message.obj=request;
// message.what=(int) arg[arg.length-3];
// handler.sendMessage(message);
//
// }
// } catch (IOException e) {
// e.printStackTrace();
// } catch (XmlPullParserException e) {
// e.printStackTrace();
// }
// }
// });
// };

/**
* 传递自定义数据类型对象(序列化后)。
* 1，自定义类对象，
* 2，方法名称，与服务端一直
* 3，请求的的service
* @return
*/
public SoapObject getBaseComplexData(Object ...arg){
String methodName = arg[arg.length-2].toString().trim();//请求方法名
Log.i("方法名称", arg[arg.length-2].toString());
String soapAction = arg[(arg.length-1)].toString()+methodName;
Log.i("参数", arg[(arg.length-1)].toString());
// 创建webservice链接对象
HttpTransportSE transport = new HttpTransportSE(arg[(arg.length-1)].toString(),10000);//10秒超时
transport.debug = true;// 是不是调试模式
// 设置链接参数
SoapObject soapObject = new SoapObject(AgbcApi.NAMESPACE, methodName);
PropertyInfo objekt = new PropertyInfo();

objekt.setName("arg0");
objekt.setValue(arg[0]);
objekt.setType(arg[0].getClass());
soapObject.addProperty(objekt);

// 设置返回参数
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);// soap协议版本必须用SoapEnvelope.VER11（Soap
envelope.dotNet = false;// 注意：这个属性是对dotnetwebservice协议的支持,若是dotnet的webservice
envelope.bodyOut = transport;
Log.i("请求参数", soapObject.toString());
envelope.setOutputSoapObject(soapObject);// 设置请求参数
new MarshalDate().register(envelope);
envelope.addMapping(AgbcApi.NAMESPACE, methodName,arg[0].getClass());// 传对象时必须，参数namespace是webservice中指定的，

(new MarshalBase64()).register(envelope);
new MarshalFloat().register(envelope);
try {
transport.call(soapAction, envelope);
if(envelope.bodyIn instanceof SoapFault){
String str = ((SoapFault) envelope.bodyIn).faultstring;
Log.i("错误信息", str);
}
else {
request=(SoapObject) envelope.bodyIn;
Object obj = envelope.getResponse();// 直接将返回值强制转换为已知对象
Log.i("返回的原始数据obj", obj.toString());
Log.i("返回的原始数据request", request.toString());
return request;
}
}
catch (IOException e) {
e.printStackTrace();
}
catch (XmlPullParserException e) {
e.printStackTrace();
}
catch (Exception ex) {
ex.printStackTrace();
}
// 解析返回的结果
return null;

};

 

/**
* 传递自定义数据类型对象(序列化后)。
* 1，自定义类对象，
* 2，方法名称，与服务端一直
* 3，请求的的service
* @return
*/
public SoapObject getBaseComplexDataNamespace(Object ...arg){
String methodName = arg[arg.length-2].toString().trim();//请求方法名
Log.i("方法名称", arg[arg.length-2].toString());
String soapAction = arg[(arg.length-1)].toString()+methodName;
Log.i("参数", arg[(arg.length-1)].toString());
// 创建webservice链接对象
HttpTransportSE transport = new HttpTransportSE(arg[(arg.length-1)].toString(),10000);//10秒超时
transport.debug = true;// 是不是调试模式

// 设置链接参数
SoapObject soapObject = new SoapObject(AgbcApi.NAMESPACETWO, methodName);
//soapObject.addProperty("", String.valueOf(1));
PropertyInfo objekt = new PropertyInfo();

objekt.setName("arg0");
objekt.setValue(arg[0]);
Log.i("类", arg[0].toString());
objekt.setType(TUser.class);
soapObject.addProperty(objekt);

// 设置返回参数
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);// soap协议版本必须用SoapEnvelope.VER11（Soap
envelope.implicitTypes=true;
envelope.dotNet = false;// 注意：这个属性是对dotnetwebservice协议的支持,若是dotnet的webservice
//envelope.implicitTypes = true;
envelope.bodyOut = transport;
Log.i("请求参数", soapObject.toString());
envelope.setOutputSoapObject(soapObject);// 设置请求参数
new MarshalDate().register(envelope);
envelope.addMapping(AgbcApi.NAMESPACETWO, methodName, TUser.class);// 传对象时必须，参数namespace是webservice中指定的，

(new MarshalBase64()).register(envelope);
new MarshalFloat().register(envelope);
try {
transport.call(soapAction, envelope);
if(envelope.bodyIn instanceof SoapFault){
String str = ((SoapFault) envelope.bodyIn).faultstring;
Log.i("错误信息", str);

}
else {
request=(SoapObject) envelope.bodyIn;
Object obj = envelope.getResponse();// 直接将返回值强制转换为已知对象
Log.i("返回的原始数据obj", obj.toString());
Log.i("返回的原始数据request", request.toString());
return request;
}
}
catch (IOException e) {
e.printStackTrace();
}
catch (XmlPullParserException e) {
e.printStackTrace();
}
catch (Exception ex) {
ex.printStackTrace();
}
// 解析返回的结果
return null;

};}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313思来想去我仍是以为应该把这个在Activity中访问网络的问题啰嗦一下，因为android 4.0以上版本系统不支持主线程存在耗时操做(包括访问网络和大数据计算等)，因此须要经过一个线程来处理，如上述代码中的红色标注部分。解决方案有不少种，最经常使用的为handler+thread、AsyncTask两种方式，在此再也不赘述，个人下一篇博客吧 至此，整个项目差很少完成了，部署，测试一下。对此，你要是在不会用webservice。我就无法了。。。。。--------------------- 做者：twjitm 来源：CSDN 原文：https://blog.csdn.net/baidu_23086307/article/details/51296371 版权声明：本文为博主原创文章，转载请附上博文连接！