写了个SharedPreferences的工具类(带加密)

/*
 * Copyright (C) 2014 Jason Fang ( ijasonfang@gmail.com )
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package fyc.framework.util;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.preference.PreferenceManager;
import android.support.v4.util.ArrayMap;
import android.text.TextUtils;

/**
 * SharePreferences Tool
 * 
 * @author Jason Fang
 * @datetime 2014年12月5日 下午5:28:22
 */
public class PrefsUtils {
    static final boolean DEBUG = true;
    
    private static final String SECURITY_KEY = "iJasonfang";
    
    /**
     * Put Value
     * 
     * @param context
     * @param key
     * @param value
     * @return
     */
    public static boolean putValue(Context context, String key, Object value) {
        return putValue(context, null, key, value);
    }
    
    public static boolean putValue(Context context, String key, Object value, boolean[] keyValueEncrypt) {
        return putValue(context, null, key, value, keyValueEncrypt);
    }
    
    public static boolean putValue(Context context, String name, String key, Object value) {
        return putValue(context, name, key, value, new boolean[]{true, true});
    }
    
    public static boolean putValue(Context context, String name, String key, Object value, boolean[] keyValueEncrypt) {
        return putValue(context, name, key, value, Context.MODE_PRIVATE, keyValueEncrypt);
    }
    
    public static boolean putValue(Context context, String name, String key, Object value, int mode, boolean[] keyValueEncrypt) {
        ArrayMap<String, Object> map = new ArrayMap<String, Object>();
        map.put(key, value);
        return putValue(context, name, map, keyValueEncrypt);
    }
    
    public static boolean putValue(Context context, String name, Map<String, Object> map, boolean[] keyValueEncrypt) {
        return putValue(context, name, map, Context.MODE_PRIVATE, keyValueEncrypt);
    }

    @TargetApi(11)
    @SuppressWarnings("unchecked")
    public static boolean putValue(Context context, String name, Map<String, Object> map, int mode, boolean[] keyValueEncrypt) {
        SharedPreferences preferences = null;
        if (TextUtils.isEmpty(name)) {
            preferences = PreferenceManager.getDefaultSharedPreferences(context);
        } else {
            preferences = context.getSharedPreferences(name, mode);
        }
        
        Editor editor = preferences.edit();
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            String key = keyValueEncrypt[0] ? SecurityUtils.MD5(entry.getKey()) : entry.getKey();
            Object value = entry.getValue();
            
            if (keyValueEncrypt[1] && !(value instanceof Set)) {
                editor.putString(key, SecurityUtils.DESencrypt(String.valueOf(value), SECURITY_KEY));
            } else {
                if (value instanceof Boolean) {
                    editor.putBoolean(key, Boolean.parseBoolean(String.valueOf(value)));
                } else if (value instanceof Float) {
                    editor.putFloat(key, Float.parseFloat(String.valueOf(value)));
                } else if (value instanceof Integer) {
                    editor.putInt(key, Integer.parseInt(String.valueOf(value)));
                } else if (value instanceof Long) {
                    editor.putLong(key, Long.parseLong(String.valueOf(value)));
                } else if (value instanceof String) {
                    editor.putString(key, String.valueOf(value));
                } else if (value instanceof Set) {
                    if (keyValueEncrypt[1]) {
                        Set<String> sets = (Set<String>)value;
                        Set<String> tempSets = new HashSet<String>();
                        for (String s : sets) {
                            tempSets.add(SecurityUtils.DESencrypt(String.valueOf(s), SECURITY_KEY));
                        }
                        editor.putStringSet(key, tempSets);
                    } else {
                        editor.putStringSet(key, (Set<String>)value);
                    }
                } else {
                    throw new IllegalArgumentException("Value type is not support!");
                }
            }
        }
        return editor.commit();
    }
    
    /**
     * Remove Key
     * @param context
     * @param key
     */
    public static boolean removeKey(Context context, String key) {
        return removeKey(context, null, key);
    }
    
    public static boolean removeKey(Context context, String name, String key) {
        return removeKey(context, name, key, false);
    }
    
    public static boolean removeKey(Context context, String name, String key, boolean isKeyEncrypt) {
        return removeKey(context, name, key, Context.MODE_PRIVATE, isKeyEncrypt);
    }
    
    public static boolean removeKey(Context context, String name, String key, int mode, boolean isKeyEncrypt) {
        SharedPreferences preferences = null;
        if (TextUtils.isEmpty(name)) {
            preferences = PreferenceManager.getDefaultSharedPreferences(context);
        } else {
            preferences = context.getSharedPreferences(name, mode);
        }
        
        Editor editor = preferences.edit();
        editor.remove(isKeyEncrypt ? SecurityUtils.DESencrypt(key, SECURITY_KEY) : key);
        return editor.commit();
    }
    
    /**
     * Get String
     * 
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static String getString(Context context, String key, String defValue) {
        return getString(context, null, key, defValue);
    }
    
    public static String getString(Context context, String name, String key, String defValue) {
        return getString(context, name, key, defValue, Context.MODE_PRIVATE, new boolean[]{true, true});
    }
    
    public static String getString(Context context, String name, String key, String defValue, boolean[] keyValueEncrypt) {
        return getString(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
    }
    
    public static String getString(Context context, String name, String key, String defValue, int mode, boolean[] keyValueEncrypt) {
        SharedPreferences preferences = null;
        if (TextUtils.isEmpty(name)) {
            preferences = PreferenceManager.getDefaultSharedPreferences(context);
        } else {
            preferences = context.getSharedPreferences(name, mode);
        }
        
        String value = preferences.getString(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
        if (value.equals(defValue)) {
            return value;
        } else {
            return keyValueEncrypt[1] ? SecurityUtils.DESdecrypt(value, SECURITY_KEY) : value;
        }
    }
    
    /**
     * Get Int
     * 
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static int getInt(Context context, String key, int defValue) {
        return getInt(context, null, key, defValue);
    }
    
    public static int getInt(Context context, String name, String key, int defValue) {
        return getInt(context, name, key, defValue, new boolean[]{true, true});
    }
    
    public static int getInt(Context context, String name, String key, int defValue, boolean[] keyValueEncrypt) {
        return getInt(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
    }

    public static int getInt(Context context, String name, String key, int defValue, int mode, boolean[] keyValueEncrypt) {
        SharedPreferences preferences = null;
        if (TextUtils.isEmpty(name)) {
            preferences = PreferenceManager.getDefaultSharedPreferences(context);
        } else {
            preferences = context.getSharedPreferences(name, mode);
        }

        if (keyValueEncrypt[1]) {
            String value = getString(context, name, key, String.valueOf(defValue), mode, keyValueEncrypt);
            try {
                return Integer.valueOf(value);
            } catch (Exception e) {
                return defValue;
            }
        } else {
            return preferences.getInt(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
        }
    }
    
    /**
     * Get Long
     * 
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static long getLong(Context context, String key, long defValue) {
        return getLong(context, null, key, defValue);
    }
    
    public static long getLong(Context context, String name, String key, long defValue) {
        return getLong(context, name, key, defValue, new boolean[]{true, true});
    }
    
    public static long getLong(Context context, String name, String key, long defValue, boolean[] keyValueEncrypt) {
        return getLong(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
    }
    
    public static long getLong(Context context, String name, String key, long defValue, int mode, boolean[] keyValueEncrypt) {
        SharedPreferences preferences = null;
        if (TextUtils.isEmpty(name)) {
            preferences = PreferenceManager.getDefaultSharedPreferences(context);
        } else {
            preferences = context.getSharedPreferences(name, mode);
        }

        if (keyValueEncrypt[1]) {
            String value = getString(context, name, key, String.valueOf(defValue), mode, keyValueEncrypt);
            
            try {
                return Long.valueOf(value);
            } catch (Exception e) {
                return defValue;
            }
        } else {
            return preferences.getLong(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
        }
    }
    
    /**
     * Get Float
     * 
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static float getFloat(Context context, String key, float defValue) {
        return getFloat(context, null, key, defValue);
    }
    
    public static float getFloat(Context context, String name, String key, float defValue) {
        return getFloat(context, name, key, defValue, new boolean[]{true, true});
    }
    
    public static float getFloat(Context context, String name, String key, float defValue, boolean[] keyValueEncrypt) {
        return getFloat(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
    }
    
    public static float getFloat(Context context, String name, String key, float defValue, int mode, boolean[] keyValueEncrypt) {
        SharedPreferences preferences = null;
        if (TextUtils.isEmpty(name)) {
            preferences = PreferenceManager.getDefaultSharedPreferences(context);
        } else {
            preferences = context.getSharedPreferences(name, mode);
        }

        if (keyValueEncrypt[1]) {
            String value = getString(context, name, key, String.valueOf(defValue), mode, keyValueEncrypt);
            try {
                return Float.valueOf(value);
            } catch (Exception e) {
                return defValue;
            }
        } else {
            return preferences.getFloat(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
        }
        
    }
    
    /**
     * boolean
     * 
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static boolean getBoolean(Context context, String key, boolean defValue) {
        return getBoolean(context, null, key, defValue);
    }
    
    public static boolean getBoolean(Context context, String name, String key, boolean defValue) {
        return getBoolean(context, name, key, defValue, new boolean[]{true, true});
    }
    
    public static boolean getBoolean(Context context, String name, String key, boolean defValue, boolean[] keyValueEncrypt) {
        return getBoolean(context, name, key, defValue, Context.MODE_PRIVATE, keyValueEncrypt);
    }
    
    public static boolean getBoolean(Context context, String name, String key, boolean defValue, int mode, boolean[] keyValueEncrypt) {
        SharedPreferences preferences = null;
        if (TextUtils.isEmpty(name)) {
            preferences = PreferenceManager.getDefaultSharedPreferences(context);
        } else {
            preferences = context.getSharedPreferences(name, mode);
        }
        
        if (keyValueEncrypt[1]) {
            String valueString = getString(context, name, key, String.valueOf(defValue), mode, keyValueEncrypt);
            try {
                return Boolean.valueOf(valueString);
            } catch (Exception e) {
                return defValue;
            }
        } else {
            return preferences.getBoolean(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValue);
        }
    }
    
    /**
     * StringSet
     * 
     * @param context
     * @param key
     * @param defValues
     * @return
     */
    public static Set<String> getStringSet(Context context, String key, Set<String> defValues) {
        return getStringSet(context, null, key, defValues);
    }
    
    public static Set<String> getStringSet(Context context, String name, String key, Set<String> defValues) {
        return getStringSet(context, name, key, defValues, new boolean[]{true, true});
    }
    
    public static Set<String> getStringSet(Context context, String name, String key, Set<String> defValues, boolean[] keyValueEncrypt) {
        return getStringSet(context, name, key, defValues, Context.MODE_PRIVATE, keyValueEncrypt);
    }
    
    /**
     * @param context
     * @param name
     * @param key
     * @param defValues
     * @param mode
     * @return
     */
    @TargetApi(11)
    public static Set<String> getStringSet(Context context, String name, String key, Set<String> defValues, int mode, boolean[] keyValueEncrypt) {
        SharedPreferences preferences = null;
        if (TextUtils.isEmpty(name)) {
            preferences = PreferenceManager.getDefaultSharedPreferences(context);
        } else {
            preferences = context.getSharedPreferences(name, mode);
        }
        Set<String> valueSet = preferences.getStringSet(keyValueEncrypt[0] ? SecurityUtils.MD5(key) : key, defValues);
        Set<String> tempValueSet = new HashSet<String>();
        for (String s : valueSet) {
            tempValueSet.add(SecurityUtils.DESdecrypt(s, SECURITY_KEY));
        }
        return tempValueSet;
    }
    
    private PrefsUtils(){/*Do not new me*/};
}

 加密工具类!

/*
 * Copyright (C) 2014 Jason Fang ( ijasonfang@gmail.com )
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package fyc.framework.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec;

import android.annotation.SuppressLint;
import android.text.TextUtils;
import android.util.Base64;

/**
 * 加密工具类
 * @description 
 * @author Jason Fang
 * @created 2013年10月31日
 */
public class SecurityUtils {
    static final boolean DEBUG = true;

/**
     * MD5
     * @param srcString
     * @return
     */
    public static String MD5(String srcString) {
        if (TextUtils.isEmpty(srcString)) {
            throw new IllegalArgumentException("srcString cannot be null!");
        }
        
        try {
            return MD5(srcString.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            return "";
        }
    }
    
    public static String MD5(byte[] srcBytes) {
        if (srcBytes == null) {
            throw new IllegalArgumentException("bytes cannot be null!");
        }
        
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(srcBytes);
            byte[] bytes = md.digest();
            int i = 0;
            StringBuffer buffer = new StringBuffer("");
            for (int offset = 0; offset < bytes.length; offset++) {
                i = bytes[offset];
                if (i < 0) {
                    i += 256;
                }
                if (i < 16) {
                    buffer.append("0");
                }
                buffer.append(Integer.toHexString(i));
            }
            return buffer.toString();
        } catch (Exception e) {
            if (DEBUG) Flog.e(e);
        }
        return "";
    }
    /**
     * @param dataSource
     * @param password
     * @return
     */
    public static String DESencrypt(String dataSource, String password) {
        return ConvertUtils.parseBytesToHexString(DESencrypt(dataSource.getBytes(), password));
    }
    
    /**
     * @param data
     * @param password
     * @return
     */
    public static String DESdecrypt(String data, String password) {
        byte[] bytes = DESdecrypt(ConvertUtils.parseHexStringToBytes(data), password);
        if (bytes == null) {
            return "";
        }
        return new String(bytes);
    }
    private SecurityUtils() {/*Do not new me*/};
}

 ConvertUtils 

/*
 * Copyright (C) 2014 Jason Fang ( ijasonfang@gmail.com )
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package fyc.framework.util;

import java.io.UnsupportedEncodingException;
import java.text.NumberFormat;
import java.util.Arrays;
import java.util.Map;
import java.util.Set;

import android.content.Context;
import android.content.res.Resources;
import android.text.TextUtils;
import android.util.TypedValue;

/**
 * 转换工具集
 * @author Jason Fang
 * @datetime 2014年11月23日 上午11:22:25
 */
public class ConvertUtils {
    static final boolean DEBUG = false;
/**
     * byte[] to String
     * @param bytes
     * @return
     */
    public static String parseBytesToHexString(byte[] bytes) {
        if (bytes == null) return "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < bytes.length; i++) {  
            String x16 = Integer.toHexString(bytes[i]);  
            if (x16.length() < 2) {
                sb.append("0" + x16);
            } else if (x16.length() > 2) {
                sb.append(x16.substring(x16.length() - 2));
            } else {
                sb.append(x16);
            }
        }  
        return sb.toString();
    }
    
    /**
     * String to byte[]
     * @param intString
     * @return
     */
    public static byte[] parseHexStringToBytes(String intString) {
        if (TextUtils.isEmpty(intString)) return null;
        
        if (intString.length() % 2 == 1) {
            intString = "0" + intString;
        }
        byte[] bytes = new byte[intString.length() / 2];
        
        try {
            for (int i = 0; i < bytes.length; i++) {  
                bytes[i] = (byte)Integer.parseInt(intString.substring(i * 2, i * 2 + 2), 16);  
            }
            
            if (DEBUG) Flog.i("===parseStringToBytes===" + bytes.toString());
            
            return bytes; 
        } catch (Exception e) {
            Flog.e(e);
            return null;
        }
    }    
}