android WebService工具类，已做数据缓存加密处理

</pre><pre name="code" class="java">

<pre name="code" class="java"><span style="font-size:24px;color:#ff6600;">仅限于.net soap1.2平台</span>

<span style="font-family: Arial, Helvetica, sans-serif;">首先依赖包：</span>

1.谷歌ksoap包：    <a target=_blank href="http://code.google.com/p/ksoap2-android/downloads/list?can=1&q=&colspec=Filename+Summary+Uploaded+Size+DownloadCount" target="_blank" style="color: rgb(48, 96, 168); text-decoration: none; font-family: 'Lucida Grande', Lucida, Arial; line-height: 18px;">http://code.google.com/p/ksoap2-android/downloads/list?can=1&q=&colspec=Filename+Summary+Uploaded+Size+DownloadCount</a>

2.<span style="font-family: 'ms song', 'Microsoft Yahei', SimHei, Verdana, Helvetica, SimSun, Arial, 'Arial Unicode MS', MingLiu, PMingLiu, 'MS Gothic', sans-serief; text-align: center; background-color: rgb(250, 250, 250);">Android 缓存框架：ASimpleCache      https://github.com/yangfuhai/ASimpleCache</span>

</pre><pre name="code" class="java">/**code by sunger
 * If you have any questions, please contact me
 * email:sungerk@foxmail.com
 */
package com.legendin.earnmoney.utils;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.kobjects.base64.Base64;
import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.MarshalFloat;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapPrimitive;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpResponseException;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;

import android.annotation.SuppressLint;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;

/**
 * dotNet平台Soap 1.2 WebService工具类
 * 不用开启线程，内部已封装。可在WSListener监听器里更新UI，内部已经将参数用handler发送 可以设置开启数据缓存，可设置缓存种子
 * 可开启数据缓存，可设置加密种子
 * 
 * @author sunger
 * 
 */

public class WSUtils implements Runnable {
	// 加载网络数据缓存默认加密种子
	private String speed = "d7db5a655d6c122d";
	private XmmaParas xmma_paras;
	// 默认不缓存数据
	private boolean isCache = false;
	@SuppressLint("HandlerLeak")
	private Handler dateCompletehandler = new Handler() {
		@Override
		public void handleMessage(android.os.Message msg) {
			Object obj = msg.obj;
			webServiceHandler.onSuccess(200, obj);
			// 如果开启了缓存则将数据加密后存入缓存
			if (isCache) {
				ACache mCache = WsACacheDao.getACache();
				try {
					String str = AESUtils.encrypt(speed, obj.toString());
					mCache.put(xmma_paras.getOpName(), str);
				} catch (Exception e) {
					e.printStackTrace();
				}

			}

		};
	};

	@SuppressLint("HandlerLeak")
	private Handler errorHandler = new Handler() {
		@Override
		public void handleMessage(android.os.Message msg) {
			Throwable error = (Throwable) msg.obj;
			// 如果加载失败则读取本地缓存
			if (isCache) {
				ACache mCache = WsACacheDao.getACache();
				String str = mCache.getAsString(xmma_paras.getOpName());
				try {
					str = AESUtils.decrypt(speed, str);
					if (!CommonUtils.isNullOrEmpty(str)) {
						webServiceHandler.onFailure(100, str, error);
						return;
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			webServiceHandler.onFailure(-1, null, error);
		};
	};

	/**
	 * 
	 * @param paras
	 *            请求参数
	 */
	public WSUtils(XmmaParas paras) {
		this(paras, false, null);
	}

	/**
	 * 
	 * @param paras
	 *            请求参数
	 * @param isCache
	 *            是否开启缓存
	 */
	public WSUtils(XmmaParas paras, boolean isCache) {
		this(paras, isCache, null);
	}

	/**
	 * 
	 * @param paras 请求参数
	 * @param isCache 是否开启缓存
	 * @param speed 缓存加密种子
	 */
	public WSUtils(XmmaParas paras, boolean isCache, String speed) {
		super();
		this.xmma_paras = paras;
		this.isCache = isCache;
		if (speed != null) {
			this.speed = speed;
		}
	}

	public XmmaParas getParas() {
		return xmma_paras;
	}

	public void setParas(XmmaParas paras) {
		this.xmma_paras = paras;
	}

	public WSListener getWebServiceHandler() {
		return webServiceHandler;
	}

	public void setWebServiceHandler(WSListener webServiceHandler) {
		this.webServiceHandler = webServiceHandler;
	}

	private WSListener webServiceHandler;

	/**
	 * 从服务器获取数据。
	 * 
	 * @param webServiceHandler
	 */
	public void getData(Context context, WSListener webServiceHandler) {
		this.webServiceHandler = webServiceHandler;
		// 如果网络没有连接直接发错错误消息给errorHandler
		if (!CommonUtils.isNetWorkConnected(context)) {
			sendEerrorMsg(new Exception("网络连接失败！"));
			return;
		}
		new Thread(this).start();
	}

	@Override
	public void run() {
		Looper.prepare();
		SoapObject requestObject = new SoapObject(xmma_paras.getNameSpace(),
				xmma_paras.getOpName());
		HashMap<String, Object> map = xmma_paras.getParas();
		if (map != null) {
			Iterator<?> iter = map.entrySet().iterator();
			while (iter.hasNext()) {
				@SuppressWarnings("rawtypes")
				Map.Entry entry = (Map.Entry) iter.next();
				String key = (String) entry.getKey();
				Object val = entry.getValue();
				// 如果是字节数据则转化成base64
				if (val instanceof byte[]) {
					byte[] d = (byte[]) val;
					String data = new String(Base64.encode(d));
					requestObject.addProperty(key, new SoapPrimitive(
							SoapEnvelope.ENC, "base64Binary", data)); // base64Binary
				} else {
					requestObject.addProperty(key, val);
				}

			}
		}
		SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
				SoapEnvelope.VER12);
		envelope.bodyOut = requestObject;
		envelope.dotNet = true;
		new MarshalFloat().register(envelope);
		HttpTransportSE transportSE = new HttpTransportSE(
				xmma_paras.getUrlString(), xmma_paras.getTimeout());
		try {
			transportSE.call(null, envelope);
		} catch (HttpResponseException e) {
			e.printStackTrace();
			sendEerrorMsg(new Exception("请求错误，请检测您的网络！"));
			return;
		} catch (IOException e) {
			e.printStackTrace();
			sendEerrorMsg(new Exception("IO异常"));
			return;
		} catch (XmlPullParserException e) {
			e.printStackTrace();
			sendEerrorMsg(new Exception("解析服务器数据失败"));
			return;
		}
		SoapObject result = (SoapObject) envelope.bodyIn;
		// 判断bodyIn是否为空
		if (result != null) {
			// 判断返回参数是不是为空
			if (result.getPropertyCount() > 0) {
				// 判断返回的数据是否为空
				String data = result.getProperty(0).toString();
				if (data != null) {
					Message msg = new Message();
					msg.obj = data;
					dateCompletehandler.sendMessage(msg);
					return;
				}
			}
		}
		sendEerrorMsg(new Exception("很抱歉获取服务器数据为空!"));

	}

	private void sendEerrorMsg(Throwable e) {
		Message msg = new Message();
		msg.obj = e;
		errorHandler.sendMessage(msg);
	}

	/**
	 * 取出webservice加密种子
	 * 
	 * @return
	 */
	public String getSpeed() {
		return speed;
	}

	/**
	 * 设置webservice加密种子
	 * 
	 * @param speed
	 */
	public void setSpeed(String speed) {
		this.speed = speed;
	}

	/**
	 * WebService监听接口
	 * 
	 * @author sunger
	 * 
	 */
	public interface WSListener {

		/**
		 * 
		 * @param statusCode
		 *            200代表获从网络取数据成功
		 * @param data
		 */
		void onSuccess(int statusCode, Object data);

		/**
		 * 
		 * @param statusCode
		 *            100代表获取数据失败，加载本地缓存成功<BR>
		 *            -1代表获取数据失败
		 * @param data
		 *            缓存中的数据，如果没有则为null
		 * @param error
		 */
		void onFailure(int statusCode, Object data, Throwable error);
	}

}

</pre><pre name="code" class="java">

加密处理类：

package com.legendin.earnmoney.utils;

import android.annotation.SuppressLint;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * 
 * 
 * Author：sunger
 */
public class AESUtils {

	public static String encrypt(String seed, String cleartext)
			throws Exception {

		byte[] rawKey = getRawKey(seed.getBytes());

		byte[] result = encrypt(rawKey, cleartext.getBytes());

		return toHex(result);

	}

	public static String decrypt(String seed, String encrypted)
			throws Exception {

		byte[] rawKey = getRawKey(seed.getBytes());

		byte[] enc = toByte(encrypted);

		byte[] result = decrypt(rawKey, enc);

		return new String(result);

	}

	@SuppressLint("TrulyRandom")
	private static byte[] getRawKey(byte[] seed) throws Exception {

		KeyGenerator kgen = KeyGenerator.getInstance("AES");

		SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");

		sr.setSeed(seed);

		kgen.init(128, sr); // 192 and 256 bits may not be available

		SecretKey skey = kgen.generateKey();

		byte[] raw = skey.getEncoded();

		return raw;

	}

	private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {

		SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");

		Cipher cipher = Cipher.getInstance("AES");

		cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(
				new byte[cipher.getBlockSize()]));

		byte[] encrypted = cipher.doFinal(clear);

		return encrypted;

	}

	private static byte[] decrypt(byte[] raw, byte[] encrypted)
			throws Exception {

		SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");

		Cipher cipher = Cipher.getInstance("AES");

		cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(
				new byte[cipher.getBlockSize()]));

		byte[] decrypted = cipher.doFinal(encrypted);

		return decrypted;

	}

	private static byte[] toByte(String hexString) {

		int len = hexString.length() / 2;

		byte[] result = new byte[len];

		for (int i = 0; i < len; i++)

			result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2),
					16).byteValue();

		return result;

	}

	private static String toHex(byte[] buf) {

		if (buf == null)

			return "";

		StringBuffer result = new StringBuffer(2 * buf.length);

		for (int i = 0; i < buf.length; i++) {

			appendHex(result, buf[i]);

		}

		return result.toString();

	}

	private final static String HEX = "0123456789ABCDEF";

	private static void appendHex(StringBuffer sb, byte b) {

		sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));

	}

}

使用示例：

XmmaParas paras = new XmmaParas();
paras.setOpName("login");
HashMap<String, Object> map = new HashMap<String, Object>();
map.put("tel", username);
map.put("pwd", pwd);
paras.setParas(map);
paras.setNameSpace(Constant.NameSpace);
paras.setUrlString(Constant.WebServiceURL);
webService = new WSUtils(paras,isCache);
webService.getData(this, new WSListener() {
					@Override
					public void onSuccess(int statusCode, Object data) {


						
					}


					@Override
					public void onFailure(int statusCode, Object data,
							Throwable error) {
						
						
					}


				}););