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
1、 新建android项目，导入jar包，添加权限
2、 修改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);
    }
}

对于这个类，需要啰嗦几句。
主要方法是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;
    }

}

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

}

需要注意的地方同第四步，此处不再赘述。
6、 编写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;
        }
    }
}

上面的方法你若是觉得太杂太乱的话，我有写了一个高度集中的方法，面对任何参数任何类型的，简单数据类型，自定义对象。。。看看吧

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;

    };
}

思来想去我还是觉得应该把这个在Activity中访问网络的问题啰嗦一下，由于android 4.0以上版本系统不支持主线程存在耗时操作(包括访问网络和大数据计算等)，所以需要通过一个线程来处理，如上述代码中的红色标注部分。解决方案有很多种，最常用的为handler+thread、AsyncTask两种方式，在此不再赘述，我的下一篇博客吧
至此，整个项目差不多完成了，部署，测试一下。对此，你要是在不会用webservice。我就没法了。。。。。。